@campnetwork/origin 1.3.0-alpha.3 → 1.3.0-alpha.6

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

@@ -294,11 +294,12 @@ declare function getDataWithIntent(this: Origin, tokenId: bigint, signer?: any,
 
 /**
  * Raises a dispute against an IP NFT.
- * Requires the caller to have the dispute bond amount in dispute tokens.
+ * Automatically handles token approval for ERC20 bonds or native token value.
+ * Includes the protocol dispute fee in the transaction.
  *
  * @param targetIpId The token ID of the IP NFT to dispute.
  * @param evidenceHash The hash of evidence supporting the dispute.
- * @param disputeTag A tag identifying the type of dispute.
+ * @param disputeTag A tag identifying the type of dispute (bytes32).
  * @returns A promise that resolves with the transaction result including the dispute ID.
  *
  * @example
@@ -306,7 +307,7 @@ declare function getDataWithIntent(this: Origin, tokenId: bigint, signer?: any,
  * const result = await origin.raiseDispute(
  *   1n,
  *   "0x1234...", // evidence hash
- *   "0x5678..." // dispute tag (e.g., "infringement", "fraud")
+ *   "0x0100000000000000000000000000000000000000000000000000000000000000" // dispute tag (bytes32)
  * );
  * ```
  */
@@ -540,6 +541,31 @@ interface DisputeProgress {
  */
 declare function getDisputeProgress(this: Origin, disputeId: bigint): Promise<DisputeProgress>;
 
+interface DisputeRequirements {
+    bondAmount: bigint;
+    protocolFee: bigint;
+    totalRequired: bigint;
+    tokenAddress: Address;
+    isNativeToken: boolean;
+    userBalance: bigint;
+    hasSufficientBalance: boolean;
+}
+/**
+ * Gets the requirements for raising a dispute, including balance check.
+ *
+ * @param userAddress The address to check balance for.
+ * @returns A promise that resolves with the dispute requirements.
+ *
+ * @example
+ * ```typescript
+ * const requirements = await origin.getDisputeRequirements(walletAddress);
+ * if (!requirements.hasSufficientBalance) {
+ *   console.log(`Need ${requirements.totalRequired} but only have ${requirements.userBalance}`);
+ * }
+ * ```
+ */
+declare function getDisputeRequirements(this: Origin, userAddress: Address): Promise<DisputeRequirements>;
+
 /**
  * Fractionalizes an IP NFT into fungible ERC20 tokens.
  * The NFT is transferred to the fractionalizer contract and a new ERC20 token is created.
@@ -908,6 +934,7 @@ declare class Origin {
     getDispute: typeof getDispute;
     canVoteOnDispute: typeof canVoteOnDispute;
     getDisputeProgress: typeof getDisputeProgress;
+    getDisputeRequirements: typeof getDisputeRequirements;
     fractionalize: typeof fractionalize;
     redeem: typeof redeem;
     getTokenForNFT: typeof getTokenForNFT;
@@ -924,6 +951,14 @@ declare class Origin {
     constructor(environment?: Environment | string, jwt?: string, viemClient?: WalletClient, baseParentId?: bigint, appId?: string);
     getJwt(): string | undefined;
     setViemClient(client: WalletClient): void;
+    /**
+     * Approves an ERC20 token for spending by a spender address if the current allowance is insufficient.
+     * Waits for the approval transaction to be confirmed before returning.
+     * @param tokenAddress The address of the ERC20 token.
+     * @param spender The address that will be approved to spend the tokens.
+     * @param amount The amount of tokens to approve.
+     */
+    approveERC20IfNeeded(tokenAddress: Address, spender: Address, amount: bigint): Promise<void>;
     /**
      * Uploads a JSON object to IPFS and returns the resulting CID.
      * @param data The JSON object to upload.

package/dist/react/index.esm.js

@@ -6789,11 +6789,12 @@ function getCurrentAccount() {
 
 /**
  * Raises a dispute against an IP NFT.
- * Requires the caller to have the dispute bond amount in dispute tokens.
+ * Automatically handles token approval for ERC20 bonds or native token value.
+ * Includes the protocol dispute fee in the transaction.
  *
  * @param targetIpId The token ID of the IP NFT to dispute.
  * @param evidenceHash The hash of evidence supporting the dispute.
- * @param disputeTag A tag identifying the type of dispute.
+ * @param disputeTag A tag identifying the type of dispute (bytes32).
  * @returns A promise that resolves with the transaction result including the dispute ID.
  *
  * @example
@@ -6801,13 +6802,46 @@ function getCurrentAccount() {
  * const result = await origin.raiseDispute(
  *   1n,
  *   "0x1234...", // evidence hash
- *   "0x5678..." // dispute tag (e.g., "infringement", "fraud")
+ *   "0x0100000000000000000000000000000000000000000000000000000000000000" // dispute tag (bytes32)
  * );
  * ```
  */
 function raiseDispute(targetIpId, evidenceHash, disputeTag) {
     return __awaiter(this, void 0, void 0, function* () {
-        return this.callContractMethod(this.environment.DISPUTE_CONTRACT_ADDRESS, this.environment.DISPUTE_ABI, "raiseDispute", [targetIpId, evidenceHash, disputeTag], { waitForReceipt: true });
+        const publicClient = getPublicClient();
+        const disputeContractAddress = this.environment
+            .DISPUTE_CONTRACT_ADDRESS;
+        const disputeAbi = this.environment.DISPUTE_ABI;
+        // Get dispute bond amount, protocol fee, and token address from the contract
+        const [disputeBond, protocolFee, disputeToken] = yield Promise.all([
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "disputeBond",
+            }),
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "protocolDisputeFee",
+            }),
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "disputeToken",
+            }),
+        ]);
+        const isNativeToken = disputeToken === zeroAddress;
+        const totalAmount = disputeBond + protocolFee;
+        if (!isNativeToken) {
+            // ERC20 token: approve the dispute contract to spend the total amount
+            yield this.approveERC20IfNeeded(disputeToken, disputeContractAddress, totalAmount);
+        }
+        // Call the raiseDispute contract method
+        // Pass the total (bond + protocol fee) as msg.value if using native token
+        return this.callContractMethod(disputeContractAddress, disputeAbi, "raiseDispute", [targetIpId, evidenceHash, disputeTag], {
+            waitForReceipt: true,
+            value: isNativeToken ? totalAmount : undefined,
+        });
     });
 }
 
@@ -6969,7 +7003,23 @@ function tagChildIp(childIpId, infringerDisputeId) {
  */
 function getDispute(disputeId) {
     return __awaiter(this, void 0, void 0, function* () {
-        return this.callContractMethod(this.environment.DISPUTE_CONTRACT_ADDRESS, this.environment.DISPUTE_ABI, "disputes", [disputeId]);
+        const result = yield this.callContractMethod(this.environment.DISPUTE_CONTRACT_ADDRESS, this.environment.DISPUTE_ABI, "disputes", [disputeId]);
+        // Contract returns a tuple, map it to the Dispute interface
+        const [initiator, targetId, disputeTag, disputeEvidenceHash, counterEvidenceHash, disputeTimestamp, assertionTimestamp, yesVotes, noVotes, status, bondAmount, protocolFeeAmount,] = result;
+        return {
+            initiator,
+            targetId,
+            disputeTag,
+            disputeEvidenceHash,
+            counterEvidenceHash,
+            disputeTimestamp,
+            assertionTimestamp,
+            yesVotes,
+            noVotes,
+            status: status,
+            bondAmount,
+            protocolFeeAmount,
+        };
     });
 }
 
@@ -7251,6 +7301,71 @@ function getDisputeProgress(disputeId) {
     });
 }
 
+/**
+ * Gets the requirements for raising a dispute, including balance check.
+ *
+ * @param userAddress The address to check balance for.
+ * @returns A promise that resolves with the dispute requirements.
+ *
+ * @example
+ * ```typescript
+ * const requirements = await origin.getDisputeRequirements(walletAddress);
+ * if (!requirements.hasSufficientBalance) {
+ *   console.log(`Need ${requirements.totalRequired} but only have ${requirements.userBalance}`);
+ * }
+ * ```
+ */
+function getDisputeRequirements(userAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const publicClient = getPublicClient();
+        const disputeContractAddress = this.environment
+            .DISPUTE_CONTRACT_ADDRESS;
+        const disputeAbi = this.environment.DISPUTE_ABI;
+        // Get dispute parameters from the contract
+        const [bondAmount, protocolFee, tokenAddress] = yield Promise.all([
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "disputeBond",
+            }),
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "protocolDisputeFee",
+            }),
+            publicClient.readContract({
+                address: disputeContractAddress,
+                abi: disputeAbi,
+                functionName: "disputeToken",
+            }),
+        ]);
+        const isNativeToken = tokenAddress === zeroAddress;
+        const totalRequired = bondAmount + protocolFee;
+        // Get user's balance
+        let userBalance;
+        if (isNativeToken) {
+            userBalance = yield publicClient.getBalance({ address: userAddress });
+        }
+        else {
+            userBalance = (yield publicClient.readContract({
+                address: tokenAddress,
+                abi: erc20Abi,
+                functionName: "balanceOf",
+                args: [userAddress],
+            }));
+        }
+        return {
+            bondAmount,
+            protocolFee,
+            totalRequired,
+            tokenAddress,
+            isNativeToken,
+            userBalance,
+            hasSufficientBalance: userBalance >= totalRequired,
+        };
+    });
+}
+
 /**
  * Fractionalizes an IP NFT into fungible ERC20 tokens.
  * The NFT is transferred to the fractionalizer contract and a new ERC20 token is created.
@@ -7622,10 +7737,11 @@ function getAppInfo(appId) {
 /**
  * Approves a spender to spend a specified amount of tokens on behalf of the owner.
  * If the current allowance is less than the specified amount, it will perform the approval.
+ * Waits for the approval transaction to be confirmed before returning.
  * @param {ApproveParams} params - The parameters for the approval.
  */
 function approveIfNeeded(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ walletClient, publicClient, tokenAddress, owner, spender, amount, }) {
+    return __awaiter(this, arguments, void 0, function* ({ walletClient, publicClient, tokenAddress, owner, spender, amount, chain, }) {
         const allowance = yield publicClient.readContract({
             address: tokenAddress,
             abi: erc20Abi,
@@ -7633,14 +7749,21 @@ function approveIfNeeded(_a) {
             args: [owner, spender],
         });
         if (allowance < amount) {
-            yield walletClient.writeContract({
+            const txHash = yield walletClient.writeContract({
                 address: tokenAddress,
                 account: owner,
                 abi: erc20Abi,
                 functionName: "approve",
                 args: [spender, amount],
-                chain: testnet,
+                chain,
             });
+            // Wait for the approval transaction to be confirmed with extra confirmations
+            yield publicClient.waitForTransactionReceipt({
+                hash: txHash,
+                confirmations: 2,
+            });
+            // Small delay to ensure RPC nodes have synced the new state
+            yield new Promise((resolve) => setTimeout(resolve, 1000));
         }
     });
 }
@@ -7809,6 +7932,7 @@ function bulkBuyAccessSmart(tokenIds, options) {
                 owner: buyer,
                 spender: this.environment.BATCH_PURCHASE_CONTRACT_ADDRESS,
                 amount: erc20.amount,
+                chain: this.environment.CHAIN,
             });
         }
         // Execute the purchase
@@ -7884,6 +8008,7 @@ class Origin {
         this.getDispute = getDispute.bind(this);
         this.canVoteOnDispute = canVoteOnDispute.bind(this);
         this.getDisputeProgress = getDisputeProgress.bind(this);
+        this.getDisputeRequirements = getDisputeRequirements.bind(this);
         // Fractionalizer module methods
         this.fractionalize = fractionalize.bind(this);
         this.redeem = redeem.bind(this);
@@ -7901,6 +8026,27 @@ class Origin {
     setViemClient(client) {
         this.viemClient = client;
     }
+    /**
+     * Approves an ERC20 token for spending by a spender address if the current allowance is insufficient.
+     * Waits for the approval transaction to be confirmed before returning.
+     * @param tokenAddress The address of the ERC20 token.
+     * @param spender The address that will be approved to spend the tokens.
+     * @param amount The amount of tokens to approve.
+     */
+    approveERC20IfNeeded(tokenAddress, spender, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_resolveWalletAddress).call(this);
+            yield approveIfNeeded({
+                walletClient: this.viemClient,
+                publicClient: getPublicClient(),
+                tokenAddress,
+                owner: account,
+                spender,
+                amount,
+                chain: this.environment.CHAIN,
+            });
+        });
+    }
     /**
      * Uploads a JSON object to IPFS and returns the resulting CID.
      * @param data The JSON object to upload.
@@ -8257,6 +8403,7 @@ class Origin {
                 owner: account,
                 spender: this.environment.MARKETPLACE_CONTRACT_ADDRESS,
                 amount: totalCost,
+                chain: this.environment.CHAIN,
             });
             return this.buyAccess(account, tokenId, totalCost, duration, paymentToken, protocolFeeBps, appFeeBps);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@campnetwork/origin",
-  "version": "1.3.0-alpha.3",
+  "version": "1.3.0-alpha.6",
   "main": "dist/core.cjs",
   "exports": {
     ".": {