@yallet/rwa-sdk 0.2.0

package/src/sdk.ts

@@ -0,0 +1,507 @@
+/**
+ * Yallet RWA SDK - Main SDK Class
+ *
+ * High-level interface for minting encrypted RWA assets as Solana cNFTs
+ */
+
+import type {
+  SDKConfig,
+  MintRequest,
+  MintResult,
+  RegisteredUser,
+  UserRegistry,
+  InvoiceData,
+  NoteData,
+  FileData,
+  PhotoData,
+  EncryptFunction,
+  TreeConfig,
+  Signer,
+} from './types.js';
+import { AssetType } from './types.js';
+import { ECIESEncryptor, createWasmEncryptor, encryptAsset } from './encryption.js';
+import {
+  buildInvoicePayload,
+  buildFilePayload,
+  buildMessagePayload,
+  buildPhotoPayload,
+} from './payloads.js';
+import { uploadEncryptedAsset, uploadMetadata, type UploadOptions } from './storage.js';
+import { generateNFTMetadata, generateInvoiceMetadata } from './metadata.js';
+import { CNFTMinter, createMinter } from './minting.js';
+import { InMemoryRegistry, createRegistry, type RegistryOptions } from './registry.js';
+import type { Keypair } from '@metaplex-foundation/umi';
+
+// ======================================
+//  RWA SDK Class
+// ======================================
+
+export class YalletRWASDK {
+  private config: SDKConfig;
+  private registry: UserRegistry;
+  private minter: CNFTMinter;
+  private encryptor: ECIESEncryptor | ReturnType<typeof createWasmEncryptor>;
+  private uploadOptions: UploadOptions;
+
+  constructor(
+    config: SDKConfig,
+    options: {
+      registry?: UserRegistry | RegistryOptions;
+      wasmEncryptFn?: EncryptFunction;
+      uploadOptions?: UploadOptions;
+    } = {}
+  ) {
+    this.config = config;
+
+    // Initialize registry
+    if (options.registry) {
+      if ('getUser' in options.registry) {
+        this.registry = options.registry;
+      } else {
+        this.registry = createRegistry(options.registry);
+      }
+    } else {
+      this.registry = new InMemoryRegistry();
+    }
+
+    // Initialize encryptor
+    if (options.wasmEncryptFn) {
+      this.encryptor = createWasmEncryptor(options.wasmEncryptFn);
+    } else {
+      this.encryptor = new ECIESEncryptor();
+    }
+
+    // Initialize minter
+    this.minter = createMinter(config);
+
+    // Upload options
+    this.uploadOptions = {
+      network: config.network,
+      apiKey: config.arweaveApiKey,
+      endpoint: config.arweaveEndpoint,
+      ...options.uploadOptions,
+    };
+  }
+
+  // ======================================
+  //  Configuration
+  // ======================================
+
+  /**
+   * Set the signer for minting transactions
+   *
+   * @param keypair - Umi keypair for signing
+   */
+  setSigner(keypair: Keypair): void {
+    this.minter.setSigner(keypair);
+  }
+
+  /**
+   * Set the Merkle tree configuration
+   *
+   * @param treeConfig - Tree configuration
+   */
+  setTreeConfig(treeConfig: TreeConfig): void {
+    this.minter.setTreeConfig(treeConfig);
+  }
+
+  /**
+   * Get the user registry
+   */
+  getRegistry(): UserRegistry {
+    return this.registry;
+  }
+
+  // ======================================
+  //  User Management
+  // ======================================
+
+  /**
+   * Register a user with their xidentity
+   *
+   * @param user - User to register
+   */
+  async registerUser(user: RegisteredUser): Promise<void> {
+    await this.registry.registerUser(user);
+  }
+
+  /**
+   * Get a registered user by Solana address
+   *
+   * @param solanaAddress - User's Solana address
+   * @returns Registered user or null
+   */
+  async getUser(solanaAddress: string): Promise<RegisteredUser | null> {
+    return this.registry.getUser(solanaAddress);
+  }
+
+  // ======================================
+  //  Minting Methods
+  // ======================================
+
+  /**
+   * Mint an encrypted invoice to a recipient.
+   * Uses extension-compatible payload (invoice bundle) so the recipient's wallet can decrypt and display.
+   *
+   * @param invoice - Invoice data
+   * @param recipientAddress - Recipient's Solana address
+   * @param options - Name, description, and optional pdf/sender/recipient for extension compatibility
+   * @returns Mint result
+   */
+  async mintInvoice(
+    invoice: InvoiceData,
+    recipientAddress: string,
+    options: {
+      name?: string;
+      description?: string;
+      pdfBase64?: string;
+      senderProfile?: Record<string, unknown>;
+      recipientProfile?: Record<string, unknown>;
+      uuid?: string;
+    } = {}
+  ): Promise<MintResult> {
+    const bundle = buildInvoicePayload(invoice, {
+      uuid: options.uuid,
+      pdfBase64: options.pdfBase64,
+      senderProfile: options.senderProfile,
+      recipientProfile: options.recipientProfile,
+    });
+    return this.mint({
+      assetType: AssetType.INVOICE,
+      assetData: bundle as unknown as InvoiceData,
+      recipientAddress,
+      name: options.name || `Invoice #${invoice.invoiceId}`,
+      description: options.description,
+      uuid: options.uuid,
+    });
+  }
+
+  /**
+   * Mint an encrypted file to a recipient (extension-compatible payload).
+   */
+  async mintFile(
+    file: FileData,
+    recipientAddress: string,
+    options: { name?: string; description?: string; uuid?: string } = {}
+  ): Promise<MintResult> {
+    const payload = buildFilePayload(file, { id: options.uuid });
+    return this.mint({
+      assetType: AssetType.FILE,
+      assetData: payload as unknown as FileData,
+      recipientAddress,
+      name: options.name || file.filename,
+      description: options.description,
+      uuid: options.uuid,
+    });
+  }
+
+  /**
+   * Mint an encrypted message/note to a recipient (extension-compatible payload, type always 'sent').
+   */
+  async mintMessage(
+    note: NoteData,
+    recipientAddress: string,
+    options: {
+      name?: string;
+      description?: string;
+      uuid?: string;
+      recipientId?: string | null;
+      recipientName?: string | null;
+      replyTo?: string | null;
+    } = {}
+  ): Promise<MintResult> {
+    const payload = buildMessagePayload(note, {
+      uuid: options.uuid,
+      recipientId: options.recipientId,
+      recipientName: options.recipientName,
+      replyTo: options.replyTo,
+    });
+    return this.mint({
+      assetType: AssetType.NOTE,
+      assetData: payload as unknown as NoteData,
+      recipientAddress,
+      name: options.name || note.title,
+      description: options.description,
+      uuid: options.uuid,
+    });
+  }
+
+  /**
+   * Mint an encrypted picture/photo to a recipient (extension-compatible payload).
+   */
+  async mintPhoto(
+    photo: PhotoData,
+    recipientAddress: string,
+    options: { name?: string; description?: string; uuid?: string; thumbnail?: string } = {}
+  ): Promise<MintResult> {
+    const payload = buildPhotoPayload(photo, {
+      id: options.uuid,
+      thumbnail: options.thumbnail,
+    });
+    return this.mint({
+      assetType: AssetType.PHOTO,
+      assetData: payload as unknown as PhotoData,
+      recipientAddress,
+      name: options.name || photo.filename,
+      description: options.description,
+      uuid: options.uuid,
+    });
+  }
+
+  /**
+   * Mint an encrypted asset to a recipient
+   *
+   * This is the main minting method that handles the full flow:
+   * 1. Look up recipient's xidentity from registry
+   * 2. Encrypt asset with recipient's xidentity
+   * 3. Upload encrypted data to Arweave
+   * 4. Generate and upload NFT metadata
+   * 5. Mint cNFT to recipient
+   *
+   * @param request - Mint request
+   * @returns Mint result
+   */
+  async mint(request: MintRequest): Promise<MintResult> {
+    const {
+      assetType,
+      assetData,
+      recipientAddress,
+      name,
+      description,
+      attributes = [],
+      // New fields
+      uuid,
+      previousToken,
+      schema,
+      mimeType,
+      dataSize,
+    } = request;
+
+    try {
+      // 1. Look up recipient's xidentity
+      const recipient = await this.registry.getUser(recipientAddress);
+
+      if (!recipient) {
+        return {
+          success: false,
+          error: `Recipient not registered: ${recipientAddress}. User must register their xidentity first.`,
+        };
+      }
+
+      console.log(`[RWA SDK] Minting ${assetType} to ${recipientAddress}`);
+
+      // 2. Encrypt asset with recipient's xidentity
+      console.log('[RWA SDK] Encrypting asset...');
+      const encryptedPayload = await encryptAsset(
+        assetData,
+        assetType,
+        recipient.xidentity,
+        this.encryptor,
+        { uuid, previousToken, schema }
+      );
+
+      // 3. Upload encrypted data to Arweave
+      console.log('[RWA SDK] Uploading encrypted data to Arweave...');
+      const dataUploadResult = await uploadEncryptedAsset(
+        encryptedPayload,
+        {
+          assetType,
+          direction: 'received',
+          network: this.config.network,
+        },
+        this.uploadOptions
+      );
+
+      console.log('[RWA SDK] Encrypted data uploaded:', dataUploadResult.id);
+
+      // 4. Generate NFT metadata with new fields
+      const nftMetadata = generateNFTMetadata({
+        name,
+        description,
+        assetType,
+        encryptedDataUri: dataUploadResult.arweaveUri,
+        owner: recipientAddress,
+        direction: 'received',
+        additionalAttributes: attributes,
+        // New fields from encryption result
+        uuid: encryptedPayload.uuid,
+        timestamp: Math.floor(encryptedPayload.timestamp / 1000), // Convert to seconds
+        previousToken,
+        schema,
+        mimeType,
+        dataSize: dataSize || encryptedPayload.dataSize,
+      });
+
+      // 5. Upload metadata to Arweave
+      console.log('[RWA SDK] Uploading metadata to Arweave...');
+      const metadataUploadResult = await uploadMetadata(
+        nftMetadata as unknown as Record<string, unknown>,
+        this.uploadOptions
+      );
+
+      console.log('[RWA SDK] Metadata uploaded:', metadataUploadResult.id);
+
+      // 6. Mint cNFT
+      console.log('[RWA SDK] Minting cNFT...');
+      const mintResult = await this.minter.mint({
+        metadataUri: metadataUploadResult.arweaveUri,
+        name,
+        recipient: recipientAddress,
+      });
+
+      if (!mintResult.success) {
+        return { ...mintResult, uuid: encryptedPayload.uuid };
+      }
+
+      console.log('[RWA SDK] cNFT minted successfully!');
+
+      return {
+        success: true,
+        assetId: mintResult.assetId,
+        signature: mintResult.signature,
+        arweaveTxId: dataUploadResult.id,
+        metadataArweaveTxId: metadataUploadResult.id,
+        uuid: encryptedPayload.uuid,
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      console.error('[RWA SDK] Minting failed:', errorMessage);
+
+      return {
+        success: false,
+        error: errorMessage,
+      };
+    }
+  }
+
+  // ======================================
+  //  Batch Minting
+  // ======================================
+
+  /**
+   * Mint multiple invoices to different recipients
+   *
+   * @param invoices - Array of invoice requests
+   * @returns Array of mint results
+   */
+  async mintInvoiceBatch(
+    invoices: Array<{
+      invoice: InvoiceData;
+      recipientAddress: string;
+      name?: string;
+    }>
+  ): Promise<MintResult[]> {
+    const results: MintResult[] = [];
+
+    for (const item of invoices) {
+      const result = await this.mintInvoice(
+        item.invoice,
+        item.recipientAddress,
+        { name: item.name }
+      );
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  // ======================================
+  //  Utility Methods
+  // ======================================
+
+  /**
+   * Check if a user is registered
+   *
+   * @param solanaAddress - User's Solana address
+   * @returns true if registered
+   */
+  async isUserRegistered(solanaAddress: string): Promise<boolean> {
+    const user = await this.registry.getUser(solanaAddress);
+    return user !== null;
+  }
+
+  /**
+   * Get the current tree configuration
+   */
+  async getTreeConfig(): Promise<TreeConfig | null> {
+    return this.minter.getTreeConfig();
+  }
+
+  /**
+   * Encrypt and upload without minting
+   * Useful for testing or when you want to handle minting separately
+   *
+   * @param assetData - Asset data to encrypt
+   * @param assetType - Type of asset
+   * @param recipientXidentity - Recipient's xidentity (base64)
+   * @returns Upload results
+   */
+  async encryptAndUpload(
+    assetData: unknown,
+    assetType: AssetType,
+    recipientXidentity: string
+  ): Promise<{
+    encryptedDataUri: string;
+    metadataUri: string;
+  }> {
+    // Encrypt
+    const encryptedPayload = await encryptAsset(
+      assetData,
+      assetType,
+      recipientXidentity,
+      this.encryptor
+    );
+
+    // Upload encrypted data
+    const dataUploadResult = await uploadEncryptedAsset(
+      encryptedPayload,
+      {
+        assetType,
+        direction: 'received',
+        network: this.config.network,
+      },
+      this.uploadOptions
+    );
+
+    // Generate and upload metadata
+    const nftMetadata = generateNFTMetadata({
+      name: `Encrypted ${assetType}`,
+      assetType,
+      encryptedDataUri: dataUploadResult.arweaveUri,
+      owner: 'pending', // Will be set during minting
+      direction: 'received',
+    });
+
+    const metadataUploadResult = await uploadMetadata(
+      nftMetadata as unknown as Record<string, unknown>,
+      this.uploadOptions
+    );
+
+    return {
+      encryptedDataUri: dataUploadResult.arweaveUri,
+      metadataUri: metadataUploadResult.arweaveUri,
+    };
+  }
+}
+
+// ======================================
+//  Factory Function
+// ======================================
+
+/**
+ * Create a new RWA SDK instance
+ *
+ * @param config - SDK configuration
+ * @param options - Additional options
+ * @returns YalletRWASDK instance
+ */
+export function createRWASDK(
+  config: SDKConfig,
+  options?: {
+    registry?: UserRegistry | RegistryOptions;
+    wasmEncryptFn?: EncryptFunction;
+    uploadOptions?: UploadOptions;
+  }
+): YalletRWASDK {
+  return new YalletRWASDK(config, options);
+}