@campnetwork/origin 1.3.0-alpha.8 → 1.3.0

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

@@ -8,7 +8,7 @@ interface Environment {
     ORIGIN_DASHBOARD: string;
     DATANFT_CONTRACT_ADDRESS: string;
     MARKETPLACE_CONTRACT_ADDRESS: string;
-    BATCH_PURCHASE_CONTRACT_ADDRESS: string;
+    BATCH_OPERATIONS_CONTRACT_ADDRESS: string;
     DISPUTE_CONTRACT_ADDRESS?: string;
     FRACTIONALIZER_CONTRACT_ADDRESS?: string;
     APP_REGISTRY_CONTRACT_ADDRESS?: string;
@@ -17,7 +17,7 @@ interface Environment {
     IPNFT_ABI?: any;
     MARKETPLACE_ABI?: any;
     TBA_ABI?: any;
-    BATCH_PURCHASE_ABI?: any;
+    BATCH_OPERATIONS_ABI?: any;
     DISPUTE_ABI?: any;
     FRACTIONALIZER_ABI?: any;
     APP_REGISTRY_ABI?: any;
@@ -244,54 +244,6 @@ declare function hasAccess(this: Origin, user: Address, tokenId: bigint): Promis
 
 declare function subscriptionExpiry(this: Origin, tokenId: bigint, user: Address): Promise<bigint>;
 
-/**
- * Response from getDataWithX402 when payment is required
- */
-interface X402Response {
-    error: string;
-    marketplaceAction?: {
-        kind: string;
-        contract: Address;
-        network: string;
-        chainId: number;
-        method: string;
-        payer: Address;
-        payTo: Address;
-        tokenId: string;
-        duration: number;
-        asset: Address;
-        amount: string;
-        amountFormatted: string;
-    };
-}
-interface TransactionResult {
-    txHash: string;
-    receipt?: any;
-}
-/**
- * EXPERIMENTAL METHOD
- * Settles a payment intent response by purchasing access if needed.
- * This method checks if the user already has access to the item, and if not,
- * it calls buyAccess with the parameters from the payment intent response.
- * Supports viem WalletClient, ethers Signer, and custom signer implementations.
- *
- * @param paymentIntentResponse - The response from getDataWithIntent containing payment details.
- * @param signer - Optional signer object used to interact with the blockchain. If not provided, uses the connected wallet client.
- * @returns A promise that resolves with the transaction hash and receipt, or null if access already exists.
- * @throws {Error} If the response doesn't contain marketplace action or if the method is not buyAccess.
- */
-declare function settlePaymentIntent(this: Origin, paymentIntentResponse: X402Response, signer?: any): Promise<TransactionResult | null>;
-
-/**
- * EXPERIMENTAL METHOD
- * Fetch data with X402 payment handling.
- * @param {bigint} tokenId The token ID to fetch data for.
- * @param {any} [signer] Optional signer object for signing the X402 intent.
- * @returns {Promise<any>} A promise that resolves with the fetched data.
- * @throws {Error} Throws an error if the data cannot be fetched or if no signer/wallet client is provided.
- */
-declare function getDataWithIntent(this: Origin, tokenId: bigint, signer?: any, decide?: (terms: any) => Promise<boolean>): Promise<any>;
-
 /**
  * Raises a dispute against an IP NFT.
  * Automatically handles token approval for ERC20 bonds or native token value.
@@ -919,11 +871,78 @@ declare function bulkBuyAccessSmart(this: Origin, tokenIds: bigint[], options?:
     tolerant?: boolean;
 }): Promise<any>;
 
+/**
+ * Parameters for a single mint in a bulk mint operation.
+ * Maps to the contract's MintParams struct.
+ */
+interface MintParams {
+    to: Address;
+    tokenId: bigint;
+    creatorContentHash: Hex;
+    uri: string;
+    licenseTerms: LicenseTerms;
+    deadline: bigint;
+    parents: bigint[];
+    isIP: boolean;
+    appId: string;
+    signature: Hex;
+}
+/**
+ * Executes an atomic bulk mint of multiple IP-NFTs.
+ * All mints succeed or all fail together.
+ *
+ * @param mints Array of mint parameters for each token.
+ * @returns A promise that resolves with the transaction result.
+ *
+ * @example
+ * ```typescript
+ * const mints = [
+ *   {
+ *     to: "0x...",
+ *     tokenId: 1n,
+ *     creatorContentHash: "0x...",
+ *     uri: "ipfs://...",
+ *     licenseTerms: { price: 1000n, duration: 86400, royaltyBps: 500, paymentToken: zeroAddress, licenseType: 0 },
+ *     deadline: BigInt(Date.now() + 600000),
+ *     parents: [],
+ *     isIP: true,
+ *     appId: "myApp",
+ *     signature: "0x...",
+ *   },
+ * ];
+ * await origin.bulkMint(mints);
+ * ```
+ */
+declare function bulkMint(this: Origin, mints: MintParams[]): Promise<any>;
+/**
+ * Executes a fault-tolerant bulk mint of multiple IP-NFTs.
+ * Individual mints can fail without reverting the entire transaction.
+ *
+ * @param mints Array of mint parameters for each token.
+ * @returns A promise that resolves with the tolerant mint result including success/failure counts.
+ *
+ * @example
+ * ```typescript
+ * const result = await origin.bulkMintTolerant(mints);
+ * console.log(`Minted ${result.successCount} of ${mints.length} tokens`);
+ * console.log(`Failed tokens: ${result.failedTokenIds}`);
+ * ```
+ */
+declare function bulkMintTolerant(this: Origin, mints: MintParams[]): Promise<any>;
+
 interface RoyaltyInfo {
     tokenBoundAccount: Address;
     balance: bigint;
     balanceFormatted: string;
 }
+interface BulkMintFileEntry {
+    file: File;
+    metadata: Record<string, unknown>;
+    license: LicenseTerms;
+    parents?: bigint[];
+    previewImage?: File | null;
+    useAssetAsPreview?: boolean;
+}
 type CallOptions = {
     value?: bigint;
     gas?: bigint;
@@ -954,14 +973,14 @@ declare class Origin {
     buyAccess: typeof buyAccess;
     hasAccess: typeof hasAccess;
     subscriptionExpiry: typeof subscriptionExpiry;
-    settlePaymentIntent: typeof settlePaymentIntent;
-    getDataWithIntent: typeof getDataWithIntent;
     bulkBuyAccess: typeof bulkBuyAccess;
     bulkBuyAccessTolerant: typeof bulkBuyAccessTolerant;
     bulkBuyAccessSmart: typeof bulkBuyAccessSmart;
     previewBulkCost: typeof previewBulkCost;
     buildPurchaseParams: typeof buildPurchaseParams;
     checkActiveStatus: typeof checkActiveStatus;
+    bulkMint: typeof bulkMint;
+    bulkMintTolerant: typeof bulkMintTolerant;
     raiseDispute: typeof raiseDispute;
     raiseDisputeSmart: typeof raiseDisputeSmart;
     disputeAssertion: typeof disputeAssertion;
@@ -1019,6 +1038,38 @@ declare class Origin {
         previewImage?: File | null;
         useAssetAsPreview?: boolean;
     }): Promise<string | null>;
+    /**
+     * Mints multiple file-based IpNFTs in a single transaction using the BatchOperations contract.
+     * Each file is uploaded and registered individually, then all mints are batched into one on-chain call.
+     *
+     * @param entries Array of file entries to mint, each containing a file, metadata, license terms, and optional parents/preview.
+     * @param options Optional configuration including tolerant mode and progress callback.
+     * @returns A promise that resolves with an array of token ID strings for each entry, and the transaction result.
+     *
+     * @example
+     * ```typescript
+     * const result = await origin.bulkMintFile([
+     *   { file: file1, metadata: { name: "Asset 1" }, license: myLicense },
+     *   { file: file2, metadata: { name: "Asset 2" }, license: myLicense },
+     * ]);
+     * console.log(`Minted token IDs: ${result.tokenIds}`);
+     *
+     * // Tolerant mode - continue even if some mints fail
+     * const result = await origin.bulkMintFile(entries, { tolerant: true });
+     * ```
+     */
+    bulkMintFile(entries: BulkMintFileEntry[], options?: {
+        tolerant?: boolean;
+        progressCallback?: (progress: {
+            fileIndex: number;
+            fileCount: number;
+            stage: "uploading" | "registering";
+            percent: number;
+        }) => void;
+    }): Promise<{
+        tokenIds: string[];
+        result: any;
+    }>;
     /**
      * Mints a social IpNFT.
      * @param source The social media source (spotify, twitter, tiktok).