Data Availability (DA)

use alith::{
    data::{
        crypto::{Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey, decrypt, encrypt},
        wallet::LocalEthWallet,
    },
    tee::marlin::{AttestationRequest, MarlinClient},
};
 
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // 1. Prepare the privacy data
    let privacy_data = b"Your Privacy Data";
    // 2. Get the signature from user's wallet.
    let signature = LocalEthWallet::random()?.sign().await?;
    // 3. Generate the RSA private key and public key
    let mut rng = rand_08::thread_rng();
    let priv_key = RsaPrivateKey::new(&mut rng, 3072)?;
    let pub_key = RsaPublicKey::from(&priv_key);
    // 4. Encrypt the privacy data and password
    let encrypted_key = pub_key.encrypt(&mut rng, Pkcs1v15Encrypt, signature.as_bytes())?;
    let encrypted_data = encrypt(privacy_data, signature.to_string())?;
    println!("Encrypted data: {:?}", hex::encode(&encrypted_data));
    println!("Encrypted key: {:?}", hex::encode(&encrypted_key));
    // 5. Decrypt the privacy data password using the RSA private key.
    let password = priv_key.decrypt(Pkcs1v15Encrypt, &encrypted_key)?;
    // 6. Decrypt the privacy data using the password
    let decrypted_data = decrypt(&encrypted_data, String::from_utf8(password)?)?;
    assert_eq!(decrypted_data.as_slice(), privacy_data);
    // 7. Generate the proof in the TEE.
    let client = MarlinClient::default();
    println!(
        "Generate the attestation within TEE: {:?}",
        client
            .attestation_hex(AttestationRequest {
                user_data: Some(decrypted_data),
                ..Default::default()
            })
            .await?
    );
    Ok(())
}

use alith::data::storage::{DataStorage, PinataIPFS, UploadOptions};
 
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let data = b"Your Data";
    let name = "file.txt";
    let token = std::env::var("IPFS_JWT")?;
    let ipfs = PinataIPFS::default();
    let file_meta = ipfs
        .upload(
            UploadOptions::builder()
                .data(data.to_vec())
                .name(name.to_string())
                .token(token.clone())
                .build(),
        )
        .await?;
    println!("Upload file to the Pinata IPFS: {:?}", file_meta);
    println!(
        "Get the shared link: {:?}",
        ipfs.get_share_link(token, file_meta.id).await?
    );
    Ok(())
}

use alith::data::storage::{DataStorage, GoogleDriveStorage, UploadOptions};
 
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let data = b"Your Data";
    let name = "file.txt";
    let storage = GoogleDriveStorage::default();
    println!(
        "Upload file to the google drive: {:?}",
        storage
            .upload(
                UploadOptions::builder()
                    .data(data.to_vec())
                    .name(name.to_string())
                    .token(std::env::var("GOOGLE_DRIVE_API_KEY")?)
                    .build()
            )
            .await?
    );
    Ok(())
}

use alith::data::storage::{DataStorage, DropboxStorage, UploadOptions};
 
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let data = b"Your Data";
    let name = "file.txt";
    let token = std::env::var("DROPBOX_API_TOKEN")?;
    let storage = DropboxStorage::default();
    let file_meta = storage
        .upload(
            UploadOptions::builder()
                .data(data.to_vec())
                .name(name.to_string())
                .token(token.clone())
                .build(),
        )
        .await?;
    println!("Upload file to the dropbox: {:?}", file_meta);
    println!(
        "Get the shared link: {:?}",
        storage.get_share_link(token, file_meta.id).await?
    );
    Ok(())
}

import os
import rsa
from alith.data import encrypt, decrypt
 
 
def main():
    privacy_data = b"Hello, Privacy Data with PGP!"
    password = os.urandom(32).hex()
    (pub_key, priv_key) = rsa.newkeys(3072)
    encrypted_key = rsa.encrypt(password.encode(), pub_key)
    encrypted_data = encrypt(privacy_data, password)
    try:
        decrypted_password = rsa.decrypt(encrypted_key, priv_key).decode()
    except rsa.DecryptionError:
        raise ValueError("RSA Failed")
    assert decrypted_password == password
    decrypted_data = decrypt(encrypted_data, decrypted_password)
    assert decrypted_data == privacy_data
    print("Crypto test successfully!")
 
 
main()

from alith.data.storage import (
    PinataIPFS,
    UploadOptions,
    GetShareLinkOptions,
    StorageError,
)
from os import getenv
import asyncio
 
 
async def main():
    ipfs = PinataIPFS()
    try:
        data = "Your data"
        name = "your_file.txt"
        token = getenv("IPFS_JWT", "")
 
        file_meta = await ipfs.upload(
            UploadOptions(name=name, data=data.encode(), token=token)
        )
        print(f"Upload file to the Pinata IPFS: {file_meta}")
        print(
            f"Share link: {await ipfs.get_share_link(GetShareLinkOptions(token=token, id=file_meta.id))}"
        )
    except StorageError as e:
        print(f"Error: {e}")
    finally:
        await ipfs.close()
 
 
if __name__ == "__main__":
    asyncio.run(main())

import { encrypt, decrypt } from "alith/data/crypto";
import NodeRSA from "node-rsa";
 
async function main() {
  const privacyData = "Hello, Privacy Data with PGP!";
  const encoder = new TextEncoder();
  const dataUint8Array = encoder.encode(privacyData);
  const password = "securepassword123456789";
  const rsa = new NodeRSA({ b: 3072 });
  const encryptedKey = rsa.encrypt(password);
  console.log("Encrypted Key:", encryptedKey.toString("base64"));
  const encryptedData = await encrypt(dataUint8Array, password);
  console.log("Encrypted Data:", encryptedData.toString());
  const decryptedPassword = rsa.decrypt(encryptedKey);
  console.log("Decrypted Password:", decryptedPassword.toString());
  const decryptedData = await decrypt(
    encryptedData,
    decryptedPassword.toString(),
  );
  console.log("Decrypted Data:", decryptedData.toString());
}
 
await main();

import { PinataIPFS } from "alith/data/storage";
 
async function main() {
  const ipfs = new PinataIPFS();
  const data = "Your privacy data";
  const name = "your_privacy_file.txt";
  const fileMeta = await ipfs.upload({
    name: name,
    data: Buffer.from(data, "utf-8"),
    token: process.env.IPFS_JWT || "",
  });
  console.log(`Upload file to the Pinata IPFS: ${fileMeta}`);
  console.log(
    `Share link: ${await ipfs.getShareLink({ token: process.env.IPFS_JWT || "", id: fileMeta.id })}`,
  );
}
 
await main();