@campnetwork/origin 1.4.0-alpha.3 → 1.4.0-alpha.5

package/dist/react/index.esm.d.ts

@@ -566,20 +566,20 @@ declare function getVaultRevenueTokens(this: Origin, tokenId: bigint): Promise<A
 
 /**
  * Returns the amount of revenue claimable by a holder for a given token and revenue token.
- * If no holder is provided, the NFT's Token Bound Account (TBA) is used,
- * since RT tokens are held in the TBA by default.
+ * If no holder is provided, the connected wallet address is used,
+ * since RT tokens are sent directly to the wallet.
  *
  * @param tokenId The token ID whose vault to query.
  * @param revenueToken The ERC20 revenue token address.
- * @param holder Optional holder address. Defaults to the NFT's TBA.
+ * @param holder Optional holder address. Defaults to the connected wallet.
  * @returns The claimable amount in the revenue token's smallest unit.
  */
 declare function claimableRevenue(this: Origin, tokenId: bigint, revenueToken: Address, holder?: Address): Promise<bigint>;
 
 /**
  * Claims accumulated revenue for a token from a specific revenue token.
- * Executes the claim through the NFT's Token Bound Account (TBA),
- * since the TBA holds the Royalty Tokens.
+ * The connected wallet must hold Royalty Tokens for the given token.
+ * Revenue is sent directly to the connected wallet.
  *
  * @param tokenId The token ID whose vault to claim from.
  * @param revenueToken The ERC20 revenue token address to claim.
@@ -589,8 +589,8 @@ declare function claimRevenue(this: Origin, tokenId: bigint, revenueToken: Addre
 
 /**
  * Claims accumulated revenue for a token from multiple revenue tokens in a single transaction.
- * Executes the claim through the NFT's Token Bound Account (TBA),
- * since the TBA holds the Royalty Tokens.
+ * The connected wallet must hold Royalty Tokens for the given token.
+ * Revenue is sent directly to the connected wallet.
  *
  * @param tokenId The token ID whose vault to claim from.
  * @param revenueTokens Array of ERC20 revenue token addresses to claim.
@@ -616,11 +616,11 @@ interface RoyaltyTokenBalance {
 }
 /**
  * Gets the Royalty Token balance for a holder in a token's vault.
- * If no holder is provided, the NFT's Token Bound Account (TBA) is used,
- * since RT tokens are minted to the TBA by default.
+ * If no holder is provided, the connected wallet address is used,
+ * since RT tokens are sent directly to the wallet.
  *
  * @param tokenId The token ID whose vault to query.
- * @param holder Optional holder address. Defaults to the NFT's TBA.
+ * @param holder Optional holder address. Defaults to the connected wallet.
  * @returns The royalty token balance info including vault address, balance, total supply, percentage, and decimals.
  */
 declare function getRoyaltyTokenBalance(this: Origin, tokenId: bigint, holder?: Address): Promise<RoyaltyTokenBalance>;
@@ -794,7 +794,7 @@ interface MintParams {
  *     creatorContentHash: "0x...",
  *     uri: "ipfs://...",
  *     licenseTerms: { price: 1000n, duration: 86400, royaltyBps: 500, paymentToken: zeroAddress, licenseType: 0 },
- *     deadline: BigInt(Date.now() + 600000),
+ *     deadline: BigInt(Math.floor(Date.now() / 1000) + 600),
  *     parents: [],
  *     isIP: true,
  *     appId: "myApp",
@@ -821,6 +821,103 @@ declare function bulkMint(this: Origin, mints: MintParams[]): Promise<any>;
  */
 declare function bulkMintTolerant(this: Origin, mints: MintParams[]): Promise<any>;
 
+interface OriginContext {
+    environment: {
+        AUTH_HUB_BASE_API: string;
+    };
+    [key: string]: any;
+}
+type IpfsPinningProvider = "pinata" | "infura" | "web3storage";
+interface IpfsCredentials {
+    provider: IpfsPinningProvider;
+    apiKey?: string;
+    apiSecret?: string;
+    jwt?: string;
+    token?: string;
+    projectId?: string;
+    projectSecret?: string;
+}
+interface IpfsUploadConfig {
+    provider: IpfsPinningProvider;
+    pinata?: {
+        jwt?: string;
+        apiKey?: string;
+        apiSecret?: string;
+    };
+    infura?: {
+        projectId: string;
+        projectSecret: string;
+        endpoint: string;
+    };
+    web3storage?: {
+        token: string;
+    };
+}
+/**
+ * Save IPFS credentials for large file uploads.
+ * Users can configure their own IPFS pinning service (Pinata, Infura, or web3.storage).
+ * @param credentials The IPFS credentials to save.
+ * @throws {APIError} If saving credentials fails.
+ * @example
+ * ```typescript
+ * // Save Pinata credentials
+ * await origin.saveIpfsCredentials({
+ *   provider: 'pinata',
+ *   jwt: 'your-pinata-jwt-token'
+ * });
+ *
+ * // Save Infura credentials
+ * await origin.saveIpfsCredentials({
+ *   provider: 'infura',
+ *   projectId: 'your-project-id',
+ *   projectSecret: 'your-project-secret'
+ * });
+ * ```
+ */
+declare function saveIpfsCredentials(this: OriginContext, credentials: IpfsCredentials): Promise<void>;
+/**
+ * Verify that saved IPFS credentials are valid.
+ * @returns Object with valid boolean and optional error message.
+ * @throws {APIError} If verification request fails.
+ */
+declare function verifyIpfsCredentials(this: OriginContext): Promise<{
+    valid: boolean;
+    error?: string;
+}>;
+/**
+ * Delete saved IPFS credentials.
+ * @throws {APIError} If deletion fails.
+ */
+declare function deleteIpfsCredentials(this: OriginContext): Promise<void>;
+/**
+ * Check if user has IPFS credentials configured.
+ * @returns True if credentials are configured, false otherwise.
+ */
+declare function hasIpfsCredentials(this: OriginContext): Promise<boolean>;
+/**
+ * Get IPFS upload config for client-side uploads.
+ * @returns IPFS config or null if not configured.
+ */
+declare function getIpfsUploadConfig(this: OriginContext): Promise<IpfsUploadConfig | null>;
+/**
+ * Upload a file to user's IPFS pinning service.
+ * @param file The file to upload.
+ * @param config The IPFS upload config.
+ * @param progressCallback Optional progress callback with intermediate upload progress.
+ * @returns The IPFS CID of the uploaded file.
+ */
+declare function uploadToUserIPFS(this: OriginContext, file: File, config: IpfsUploadConfig, progressCallback?: (percent: number) => void): Promise<string>;
+/**
+ * Register an IPFS file with the backend after client-side upload.
+ * @param cid The IPFS CID of the uploaded file.
+ * @param fileName The original file name.
+ * @param fileType The file MIME type.
+ * @returns The registered file key.
+ */
+declare function registerIpfsFile(this: OriginContext, cid: string, fileName: string, fileType: string): Promise<{
+    fileKey: string;
+}>;
+
 interface RoyaltyInfo {
     tokenBoundAccount: Address;
     balance: bigint;
@@ -891,6 +988,13 @@ declare class Origin {
     deployVaultForExistingNFT: typeof deployVaultForExistingNFT;
     getRoyaltyTokenBalance: typeof getRoyaltyTokenBalance;
     getAppInfo: typeof getAppInfo;
+    saveIpfsCredentials: typeof saveIpfsCredentials;
+    verifyIpfsCredentials: typeof verifyIpfsCredentials;
+    deleteIpfsCredentials: typeof deleteIpfsCredentials;
+    hasIpfsCredentials: typeof hasIpfsCredentials;
+    getIpfsUploadConfig: typeof getIpfsUploadConfig;
+    uploadToUserIPFS: typeof uploadToUserIPFS;
+    registerIpfsFile: typeof registerIpfsFile;
     private jwt?;
     environment: Environment;
     private viemClient?;
@@ -920,13 +1024,14 @@ declare class Origin {
      * @param metadata The metadata associated with the file.
      * @param license The license terms for the IpNFT.
      * @param parents Optional parent token IDs for lineage tracking.
-     * @param options Optional parameters including progress callback, preview image, and use asset as preview flag.
+     * @param options Optional parameters including progress callback, preview image, use asset as preview flag, and forceIpfs.
      * @returns The token ID of the minted IpNFT as a string, or null if minting failed.
      */
     mintFile(file: File, metadata: Record<string, unknown>, license: LicenseTerms, parents?: bigint[], options?: {
         progressCallback?: (percent: number) => void;
         previewImage?: File | null;
         useAssetAsPreview?: boolean;
+        forceIpfs?: boolean;
     }): Promise<string | null>;
     /**
      * Mints multiple file-based IpNFTs in a single transaction using the BatchOperations contract.
@@ -950,6 +1055,7 @@ declare class Origin {
      */
     bulkMintFile(entries: BulkMintFileEntry[], options?: {
         tolerant?: boolean;
+        forceIpfs?: boolean;
         progressCallback?: (progress: {
             fileIndex: number;
             fileCount: number;
@@ -1067,6 +1173,12 @@ declare class Origin {
      * ```
      */
     claimRoyalties(tokenId: bigint, recipient?: Address, token?: Address): Promise<any>;
+    /**
+     * Get the connected wallet address.
+     * @returns {Promise<Address>} The connected wallet address.
+     * @throws {WalletError} Throws if no wallet is connected.
+     */
+    getWalletAddress(): Promise<Address>;
 }
 
 interface StorageAdapter {