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

package/dist/react/index.esm.js

@@ -1,6 +1,6 @@
 'use client';
 import React, { createContext, useState, useContext, useEffect, useLayoutEffect, useRef, useSyncExternalStore } from 'react';
-import { custom, createWalletClient, createPublicClient, http, zeroAddress, erc20Abi as erc20Abi$1, encodeFunctionData, getAbiItem, formatEther, formatUnits, checksumAddress, parseEther } from 'viem';
+import { custom, createWalletClient, createPublicClient, http, zeroAddress, erc20Abi as erc20Abi$1, getAbiItem, formatEther, formatUnits, encodeFunctionData, checksumAddress, parseEther } from 'viem';
 import { toAccount } from 'viem/accounts';
 import { createSiweMessage } from 'viem/siwe';
 import axios from 'axios';
@@ -6599,6 +6599,7 @@ var constants = {
     SUPPORTED_VIDEO_FORMATS: ["video/mp4", "video/webm"],
     SUPPORTED_AUDIO_FORMATS: ["audio/mpeg", "audio/wav", "audio/ogg"],
     SUPPORTED_TEXT_FORMATS: ["text/plain"],
+    MAX_FILE_SIZE: 20 * 1024 * 1024, // 20 MB
     AVAILABLE_SOCIALS: ["twitter", "spotify"], // tiktok disabled
     MAX_LICENSE_DURATION: 2628000, // 30 days in seconds
     MIN_LICENSE_DURATION: 86400, // 1 day in seconds
@@ -8032,17 +8033,17 @@ function getVaultRevenueTokens(tokenId) {
 
 /**
  * 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.
  */
 function claimableRevenue(tokenId, revenueToken, holder) {
     return __awaiter(this, void 0, void 0, function* () {
-        const holderAddress = holder || (yield this.getTokenBoundAccount(tokenId));
+        const holderAddress = holder || (yield this.getWalletAddress());
         const amount = yield this.callContractMethod(this.environment.MARKETPLACE_CONTRACT_ADDRESS, this.environment.MARKETPLACE_ABI, "claimableRevenue", [tokenId, holderAddress, revenueToken]);
         return amount;
     });
@@ -8050,8 +8051,8 @@ function claimableRevenue(tokenId, revenueToken, holder) {
 
 /**
  * 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.
@@ -8059,25 +8060,14 @@ function claimableRevenue(tokenId, revenueToken, holder) {
  */
 function claimRevenue(tokenId, revenueToken) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tokenBoundAccount = yield this.getTokenBoundAccount(tokenId);
-        const data = encodeFunctionData({
-            abi: this.environment.MARKETPLACE_ABI,
-            functionName: "claimRevenue",
-            args: [tokenId, revenueToken],
-        });
-        return this.callContractMethod(tokenBoundAccount, this.environment.TBA_ABI, "execute", [
-            this.environment.MARKETPLACE_CONTRACT_ADDRESS,
-            BigInt(0),
-            data,
-            0,
-        ], { waitForReceipt: true, value: BigInt(0) });
+        return this.callContractMethod(this.environment.MARKETPLACE_CONTRACT_ADDRESS, this.environment.MARKETPLACE_ABI, "claimRevenue", [tokenId, revenueToken], { waitForReceipt: true });
     });
 }
 
 /**
  * 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.
@@ -8085,18 +8075,7 @@ function claimRevenue(tokenId, revenueToken) {
  */
 function claimRevenueBatch(tokenId, revenueTokens) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tokenBoundAccount = yield this.getTokenBoundAccount(tokenId);
-        const data = encodeFunctionData({
-            abi: this.environment.MARKETPLACE_ABI,
-            functionName: "claimRevenueBatch",
-            args: [tokenId, revenueTokens],
-        });
-        return this.callContractMethod(tokenBoundAccount, this.environment.TBA_ABI, "execute", [
-            this.environment.MARKETPLACE_CONTRACT_ADDRESS,
-            BigInt(0),
-            data,
-            0,
-        ], { waitForReceipt: true, value: BigInt(0) });
+        return this.callContractMethod(this.environment.MARKETPLACE_CONTRACT_ADDRESS, this.environment.MARKETPLACE_ABI, "claimRevenueBatch", [tokenId, revenueTokens], { waitForReceipt: true });
     });
 }
 
@@ -8138,17 +8117,17 @@ const erc20Abi = [
 ];
 /**
  * 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.
  */
 function getRoyaltyTokenBalance(tokenId, holder) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Default to the NFT's TBA, since RT tokens are minted there
-        const holderAddress = holder || (yield this.getTokenBoundAccount(tokenId));
+        // Default to the connected wallet, since RT tokens are sent there directly
+        const holderAddress = holder || (yield this.getWalletAddress());
         // Get vault address
         const vaultAddress = yield this.callContractMethod(this.environment.DATANFT_CONTRACT_ADDRESS, this.environment.IPNFT_ABI, "getRoyaltyVault", [tokenId]);
         if (!vaultAddress || vaultAddress === zeroAddress) {
@@ -8434,7 +8413,7 @@ function bulkBuyAccessSmart(tokenIds, options) {
  *     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",
@@ -8465,6 +8444,311 @@ function bulkMintTolerant(mints) {
     return this.callContractMethod(this.environment.BATCH_OPERATIONS_CONTRACT_ADDRESS, this.environment.BATCH_OPERATIONS_ABI, "bulkMintTolerant", [mints], { waitForReceipt: true });
 }
 
+function validateIpfsCredentials(credentials) {
+    switch (credentials.provider) {
+        case "pinata":
+            if (!credentials.jwt && !(credentials.apiKey && credentials.apiSecret)) {
+                throw new ValidationError("Pinata requires either 'jwt' or both 'apiKey' and 'apiSecret'");
+            }
+            break;
+        case "infura":
+            if (!credentials.projectId || !credentials.projectSecret) {
+                throw new ValidationError("Infura requires both 'projectId' and 'projectSecret'");
+            }
+            break;
+        case "web3storage":
+            if (!credentials.token) {
+                throw new ValidationError("web3.storage requires 'token'");
+            }
+            break;
+        default:
+            throw new ValidationError(`Unsupported IPFS provider: ${credentials.provider}`);
+    }
+}
+/**
+ * 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'
+ * });
+ * ```
+ */
+function saveIpfsCredentials(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        // Validate credentials before sending
+        validateIpfsCredentials(credentials);
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(credentials),
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to save IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+    });
+}
+/**
+ * Verify that saved IPFS credentials are valid.
+ * @returns Object with valid boolean and optional error message.
+ * @throws {APIError} If verification request fails.
+ */
+function verifyIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials/verify`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { valid: false, error: "No IPFS credentials configured" };
+            }
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to verify IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+        return response.json();
+    });
+}
+/**
+ * Delete saved IPFS credentials.
+ * @throws {APIError} If deletion fails.
+ */
+function deleteIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+            },
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to delete IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+    });
+}
+/**
+ * Check if user has IPFS credentials configured.
+ * @returns True if credentials are configured, false otherwise.
+ */
+function hasIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!this.jwt) {
+            return false;
+        }
+        try {
+            const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.jwt}`,
+                },
+            });
+            if (!response.ok) {
+                return false;
+            }
+            const data = yield response.json();
+            return ((_a = data.data) === null || _a === void 0 ? void 0 : _a.hasCredentials) || false;
+        }
+        catch (_b) {
+            return false;
+        }
+    });
+}
+/**
+ * Get IPFS upload config for client-side uploads.
+ * @returns IPFS config or null if not configured.
+ */
+function getIpfsUploadConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            return null;
+        }
+        try {
+            const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/upload-config`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.jwt}`,
+                },
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const result = yield response.json();
+            return result.data || null;
+        }
+        catch (_a) {
+            return 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.
+ */
+function uploadToUserIPFS(file, config, progressCallback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        // Validate file input
+        if (!file || !(file instanceof File)) {
+            throw new ValidationError("Invalid file: must be a File object");
+        }
+        if (file.size === 0) {
+            throw new ValidationError("Cannot upload empty file");
+        }
+        progressCallback === null || progressCallback === void 0 ? void 0 : progressCallback(0);
+        const onUploadProgress = progressCallback
+            ? (progressEvent) => {
+                if (progressEvent.total) {
+                    const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+                    progressCallback(percent);
+                }
+            }
+            : undefined;
+        let cid;
+        switch (config.provider) {
+            case "pinata": {
+                const formData = new FormData();
+                formData.append("file", file);
+                const headers = {};
+                if ((_a = config.pinata) === null || _a === void 0 ? void 0 : _a.jwt) {
+                    headers["Authorization"] = `Bearer ${config.pinata.jwt}`;
+                }
+                else if (((_b = config.pinata) === null || _b === void 0 ? void 0 : _b.apiKey) && ((_c = config.pinata) === null || _c === void 0 ? void 0 : _c.apiSecret)) {
+                    headers["pinata_api_key"] = config.pinata.apiKey;
+                    headers["pinata_secret_api_key"] = config.pinata.apiSecret;
+                }
+                try {
+                    const response = yield axios.post("https://api.pinata.cloud/pinning/pinFileToIPFS", formData, { headers, onUploadProgress, timeout: 600000 });
+                    cid = response.data.IpfsHash;
+                }
+                catch (error) {
+                    const status = (_d = error.response) === null || _d === void 0 ? void 0 : _d.status;
+                    const message = ((_g = (_f = (_e = error.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.error) === null || _g === void 0 ? void 0 : _g.details) ||
+                        ((_j = (_h = error.response) === null || _h === void 0 ? void 0 : _h.data) === null || _j === void 0 ? void 0 : _j.message) ||
+                        error.message;
+                    throw new APIError(`Pinata IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            case "infura": {
+                if (!config.infura) {
+                    throw new Error("Infura config missing");
+                }
+                const formData = new FormData();
+                formData.append("file", file);
+                const auth = btoa(`${config.infura.projectId}:${config.infura.projectSecret}`);
+                try {
+                    const response = yield axios.post(`${config.infura.endpoint}/api/v0/add`, formData, {
+                        headers: { Authorization: `Basic ${auth}` },
+                        onUploadProgress,
+                        timeout: 600000,
+                    });
+                    cid = response.data.Hash;
+                }
+                catch (error) {
+                    const status = (_k = error.response) === null || _k === void 0 ? void 0 : _k.status;
+                    const message = ((_m = (_l = error.response) === null || _l === void 0 ? void 0 : _l.data) === null || _m === void 0 ? void 0 : _m.Message) || error.message;
+                    throw new APIError(`Infura IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            case "web3storage": {
+                if (!((_o = config.web3storage) === null || _o === void 0 ? void 0 : _o.token)) {
+                    throw new Error("web3.storage config missing");
+                }
+                try {
+                    const response = yield axios.post("https://api.web3.storage/upload", file, {
+                        headers: {
+                            Authorization: `Bearer ${config.web3storage.token}`,
+                            "X-Name": file.name,
+                        },
+                        onUploadProgress,
+                        timeout: 600000,
+                    });
+                    cid = response.data.cid;
+                }
+                catch (error) {
+                    const status = (_p = error.response) === null || _p === void 0 ? void 0 : _p.status;
+                    const message = ((_r = (_q = error.response) === null || _q === void 0 ? void 0 : _q.data) === null || _r === void 0 ? void 0 : _r.message) || error.message;
+                    throw new APIError(`web3.storage IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            default:
+                throw new ValidationError(`Unsupported IPFS provider: ${config.provider}. Supported providers: pinata, infura, web3storage`);
+        }
+        if (!cid || typeof cid !== "string") {
+            throw new APIError(`IPFS upload to ${config.provider} succeeded but returned no CID`);
+        }
+        progressCallback === null || progressCallback === void 0 ? void 0 : progressCallback(100);
+        return cid;
+    });
+}
+/**
+ * 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.
+ */
+function registerIpfsFile(cid, fileName, fileType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS file registration");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/register-file`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ cid, fileName, fileType }),
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to register IPFS file (HTTP ${response.status})`, response.status);
+        }
+        const result = yield response.json();
+        return { fileKey: result.data.fileKey };
+    });
+}
+
 var _Origin_instances, _Origin_generateURL, _Origin_setOriginStatus, _Origin_uploadToIPFS, _Origin_uploadFile, _Origin_waitForTxReceipt, _Origin_ensureChainId, _Origin_getCurrentAccount, _Origin_getProtocolFeeBps, _Origin_getAppFeeBpsForToken, _Origin_resolveWalletAddress;
 /**
  * The Origin class
@@ -8538,6 +8822,14 @@ class Origin {
         this.getRoyaltyTokenBalance = getRoyaltyTokenBalance.bind(this);
         // AppRegistry module methods
         this.getAppInfo = getAppInfo.bind(this);
+        // IPFS credentials methods
+        this.saveIpfsCredentials = saveIpfsCredentials.bind(this);
+        this.verifyIpfsCredentials = verifyIpfsCredentials.bind(this);
+        this.deleteIpfsCredentials = deleteIpfsCredentials.bind(this);
+        this.hasIpfsCredentials = hasIpfsCredentials.bind(this);
+        this.getIpfsUploadConfig = getIpfsUploadConfig.bind(this);
+        this.uploadToUserIPFS = uploadToUserIPFS.bind(this);
+        this.registerIpfsFile = registerIpfsFile.bind(this);
     }
     getJwt() {
         return this.jwt;
@@ -8591,7 +8883,7 @@ 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, metadata, license, parents, options) {
@@ -8603,17 +8895,37 @@ class Origin {
             catch (error) {
                 throw new WalletError(`Cannot mint file "${file.name}": wallet not connected. Please connect a wallet first.`);
             }
+            // Check if we should use IPFS for this file
+            const shouldUseIpfs = (options === null || options === void 0 ? void 0 : options.forceIpfs) || file.size > constants.MAX_FILE_SIZE;
             let info;
-            try {
-                info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, options);
-                if (!info || !info.key) {
-                    throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+            if (shouldUseIpfs) {
+                // Large file - use user's IPFS pinning service
+                const ipfsConfig = yield this.getIpfsUploadConfig();
+                if (!ipfsConfig) {
+                    throw new APIError(`File "${file.name}" exceeds 20MB limit. Please configure your IPFS pinning service in Settings to upload large files.`);
+                }
+                try {
+                    const cid = yield this.uploadToUserIPFS(file, ipfsConfig, options === null || options === void 0 ? void 0 : options.progressCallback);
+                    const { fileKey } = yield this.registerIpfsFile(cid, file.name, file.type);
+                    info = { key: fileKey, uploadId: "" };
+                }
+                catch (error) {
+                    throw new APIError(`Failed to upload file "${file.name}" to IPFS: ${getErrorMessage(error)}`);
                 }
             }
-            catch (error) {
-                if (error instanceof APIError || error instanceof WalletError)
-                    throw error;
-                throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+            else {
+                // Normal file - use S3
+                try {
+                    info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, options);
+                    if (!info || !info.key) {
+                        throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof APIError || error instanceof WalletError)
+                        throw error;
+                    throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                }
             }
             if (file.type) {
                 metadata.mimetype = file.type;
@@ -8629,7 +8941,7 @@ class Origin {
             if (previewImageIpfsHash) {
                 metadata.image = `ipfs://${previewImageIpfsHash}`;
             }
-            const deadline = BigInt(Date.now() + 600000); // 10 minutes from now
+            const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); // 10 minutes from now
             if (this.baseParentId) {
                 if (!parents) {
                     parents = [];
@@ -8643,7 +8955,10 @@ class Origin {
                 parents, this.appId);
             }
             catch (error) {
-                yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                // Only update S3 status if we have an uploadId (non-IPFS flow)
+                if (info.uploadId) {
+                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                }
                 throw new Error(`Failed to register IpNFT: ${error instanceof Error ? error.message : String(error)}`);
             }
             const { tokenId, signerAddress, creatorContentHash, signature, uri } = registration;
@@ -8657,12 +8972,18 @@ class Origin {
             try {
                 const mintResult = yield this.mintWithSignature(account, tokenId, parents || [], true, creatorContentHash, uri, license, deadline, signature, this.appId);
                 if (["0x1", "success"].indexOf(mintResult.receipt.status) === -1) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    // Only update S3 status if we have an uploadId (non-IPFS flow)
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Minting failed with status: ${mintResult.receipt.status}`);
                 }
             }
             catch (error) {
-                yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                // Only update S3 status if we have an uploadId (non-IPFS flow)
+                if (info.uploadId) {
+                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                }
                 throw new Error(`Minting transaction failed: ${error instanceof Error ? error.message : String(error)}`);
             }
             return tokenId.toString();
@@ -8709,10 +9030,15 @@ class Origin {
                 const { file, metadata, license } = entry;
                 let { parents } = entry;
                 // Upload file
+                const shouldUseIpfs = (options === null || options === void 0 ? void 0 : options.forceIpfs) || file.size > constants.MAX_FILE_SIZE;
                 let info;
-                try {
-                    info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, {
-                        progressCallback: (percent) => {
+                if (shouldUseIpfs) {
+                    const ipfsConfig = yield this.getIpfsUploadConfig();
+                    if (!ipfsConfig) {
+                        throw new APIError(`File "${file.name}" exceeds 20MB limit. Please configure your IPFS pinning service in Settings to upload large files.`);
+                    }
+                    try {
+                        const cid = yield this.uploadToUserIPFS(file, ipfsConfig, (percent) => {
                             var _a;
                             (_a = options === null || options === void 0 ? void 0 : options.progressCallback) === null || _a === void 0 ? void 0 : _a.call(options, {
                                 fileIndex: i,
@@ -8720,16 +9046,38 @@ class Origin {
                                 stage: "uploading",
                                 percent,
                             });
-                        },
-                    });
-                    if (!info || !info.key) {
-                        throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                        });
+                        const { fileKey } = yield this.registerIpfsFile(cid, file.name, file.type);
+                        info = { key: fileKey, uploadId: "" };
+                    }
+                    catch (error) {
+                        if (error instanceof APIError)
+                            throw error;
+                        throw new APIError(`Failed to upload file "${file.name}" to IPFS: ${getErrorMessage(error)}`);
                     }
                 }
-                catch (error) {
-                    if (error instanceof APIError || error instanceof WalletError)
-                        throw error;
-                    throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                else {
+                    try {
+                        info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, {
+                            progressCallback: (percent) => {
+                                var _a;
+                                (_a = options === null || options === void 0 ? void 0 : options.progressCallback) === null || _a === void 0 ? void 0 : _a.call(options, {
+                                    fileIndex: i,
+                                    fileCount: entries.length,
+                                    stage: "uploading",
+                                    percent,
+                                });
+                            },
+                        });
+                        if (!info || !info.key) {
+                            throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof APIError || error instanceof WalletError)
+                            throw error;
+                        throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                    }
                 }
                 uploadInfos.push(info);
                 // Set mimetype
@@ -8747,7 +9095,7 @@ class Origin {
                 if (previewImageIpfsHash) {
                     metadata.image = `ipfs://${previewImageIpfsHash}`;
                 }
-                const deadline = BigInt(Date.now() + 600000); // 10 minutes from now
+                const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); // 10 minutes from now
                 // Prepare parents
                 if (this.baseParentId) {
                     if (!parents) {
@@ -8769,12 +9117,16 @@ class Origin {
                     parents, this.appId);
                 }
                 catch (error) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Failed to register IpNFT for file "${file.name}": ${error instanceof Error ? error.message : String(error)}`);
                 }
                 const { tokenId, creatorContentHash, signature, uri } = registration;
                 if (!tokenId || !creatorContentHash || signature === undefined || !uri) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Failed to register IpNFT for file "${file.name}": Missing required fields in registration response.`);
                 }
                 tokenIds.push(tokenId.toString());
@@ -8803,8 +9155,10 @@ class Origin {
                 return { tokenIds, result };
             }
             catch (error) {
-                // Mark all uploads as failed
+                // Mark all S3 uploads as failed (skip IPFS entries with no uploadId)
                 for (const info of uploadInfos) {
+                    if (!info.uploadId)
+                        continue;
                     try {
                         yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
                     }
@@ -9242,6 +9596,16 @@ class Origin {
             { waitForReceipt: true, value: BigInt(0) });
         });
     }
+    /**
+     * Get the connected wallet address.
+     * @returns {Promise<Address>} The connected wallet address.
+     * @throws {WalletError} Throws if no wallet is connected.
+     */
+    getWalletAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_resolveWalletAddress).call(this);
+        });
+    }
 }
 _Origin_instances = new WeakSet(), _Origin_generateURL = function _Origin_generateURL(file, partCount) {
     return __awaiter(this, void 0, void 0, function* () {