@campnetwork/origin 1.3.0-alpha.1 → 1.3.0-alpha.10

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, encodeFunctionData, checksumAddress, zeroAddress, keccak256, toBytes, toHex, erc20Abi, getAbiItem, formatEther, formatUnits, parseEther } from 'viem';
+import { custom, createWalletClient, createPublicClient, http, encodeFunctionData, checksumAddress, zeroAddress, keccak256, toBytes, erc20Abi, getAbiItem, formatEther, formatUnits, parseEther } from 'viem';
 import { toAccount } from 'viem/accounts';
 import { createSiweMessage } from 'viem/siwe';
 import axios from 'axios';
@@ -3695,1237 +3695,1237 @@ var batchPurchaseAbi = [
 
 var disputeAbi = [
 	{
-		type: "constructor",
 		inputs: [
 		],
-		stateMutability: "nonpayable"
+		stateMutability: "nonpayable",
+		type: "constructor"
 	},
 	{
-		type: "function",
-		name: "UPGRADE_INTERFACE_VERSION",
 		inputs: [
-		],
-		outputs: [
 			{
-				name: "",
-				type: "string",
-				internalType: "string"
+				internalType: "address",
+				name: "target",
+				type: "address"
 			}
 		],
-		stateMutability: "view"
+		name: "AddressEmptyCode",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "cancelDispute",
 		inputs: [
-			{
-				name: "id",
-				type: "uint256",
-				internalType: "uint256"
-			}
 		],
-		outputs: [
+		name: "AlreadyVoted",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "nonpayable"
+		name: "CoolDownPeriodActive",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "CoolDownPeriodOver",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeAssertion",
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "_counterEvidenceHash",
-				type: "bytes32",
-				internalType: "bytes32"
+				internalType: "address",
+				name: "implementation",
+				type: "address"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "ERC1967InvalidImplementation",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeBond",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "ERC1967NonPayable",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "EvidenceAlreadyUsed",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeCoolDownPeriod",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "FailedCall",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "InvalidBondFeeBps",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeCounter",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "InvalidChildIpId",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "InvalidDisputeStatus",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeJudgementPeriod",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "InvalidDisputeTag",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "InvalidEvidenceHash",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeQuorum",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "InvalidInitialization",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "InvalidTargetIp",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputeToken",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "address",
-				internalType: "contract IERC20"
-			}
+		name: "NoVotingPower",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "NotAParentIp",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "disputes",
 		inputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			}
 		],
-		outputs: [
-			{
-				name: "initiator",
-				type: "address",
-				internalType: "address"
-			},
-			{
-				name: "targetId",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "disputeTag",
-				type: "bytes32",
-				internalType: "bytes32"
-			},
-			{
-				name: "disputeEvidenceHash",
-				type: "bytes32",
-				internalType: "bytes32"
-			},
-			{
-				name: "counterEvidenceHash",
-				type: "bytes32",
-				internalType: "bytes32"
-			},
-			{
-				name: "disputeTimestamp",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "assertionTimestamp",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "yesVotes",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "noVotes",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "status",
-				type: "uint8",
-				internalType: "enum DisputeModule.DisputeStatus"
-			},
-			{
-				name: "bondAmount",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "protocolFeeAmount",
-				type: "uint256",
-				internalType: "uint256"
-			}
+		name: "NotInitializing",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "NotInitiator",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "hasVoted",
 		inputs: [
-			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "",
-				type: "address",
-				internalType: "address"
-			}
 		],
-		outputs: [
+		name: "NotTokenOwner",
+		type: "error"
+	},
+	{
+		inputs: [
 			{
-				name: "",
-				type: "bool",
-				internalType: "bool"
+				internalType: "address",
+				name: "owner",
+				type: "address"
 			}
 		],
-		stateMutability: "view"
+		name: "OwnableInvalidOwner",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "initialize",
 		inputs: [
 			{
-				name: "_ipToken",
-				type: "address",
-				internalType: "contract IIpNFT"
-			},
-			{
-				name: "_marketplace",
-				type: "address",
-				internalType: "contract IMarketplace"
-			},
-			{
-				name: "_disputeToken",
-				type: "address",
-				internalType: "contract IERC20"
-			},
-			{
-				name: "_disputeBond",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "_disputeCoolDownPeriod",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "_disputeJudgementPeriod",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "_bondFeeBPS",
-				type: "uint16",
-				internalType: "uint16"
-			},
-			{
-				name: "_stakingThreshold",
-				type: "uint256",
-				internalType: "uint256"
-			},
-			{
-				name: "_stakingVault",
-				type: "address",
-				internalType: "contract ICampStakingVault"
+				internalType: "address",
+				name: "account",
+				type: "address"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "OwnableUnauthorizedAccount",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "ipToken",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "address",
-				internalType: "contract IIpNFT"
-			}
-		],
-		stateMutability: "view"
+		name: "ParentNotDisputed",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "isUsedEvidenceHash",
 		inputs: [
-			{
-				name: "",
-				type: "bytes32",
-				internalType: "bytes32"
-			}
-		],
-		outputs: [
-			{
-				name: "",
-				type: "bool",
-				internalType: "bool"
-			}
 		],
-		stateMutability: "view"
+		name: "SelfAssertionNotAllowed",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "marketplace",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "address",
-				internalType: "contract IMarketplace"
-			}
-		],
-		stateMutability: "view"
+		name: "StakedAfterDispute",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "owner",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "address",
-				internalType: "address"
-			}
-		],
-		stateMutability: "view"
+		name: "TagNotAllowed",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "protocolDisputeFee",
 		inputs: [
 		],
-		outputs: [
+		name: "UUPSUnauthorizedCallContext",
+		type: "error"
+	},
+	{
+		inputs: [
 			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
+				internalType: "bytes32",
+				name: "slot",
+				type: "bytes32"
 			}
 		],
-		stateMutability: "view"
+		name: "UUPSUnsupportedProxiableUUID",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "proxiableUUID",
 		inputs: [
 		],
-		outputs: [
-			{
-				name: "",
-				type: "bytes32",
-				internalType: "bytes32"
-			}
+		name: "VotingPeriodActive",
+		type: "error"
+	},
+	{
+		inputs: [
 		],
-		stateMutability: "view"
+		name: "VotingPeriodOver",
+		type: "error"
 	},
 	{
-		type: "function",
-		name: "raiseDispute",
+		anonymous: false,
 		inputs: [
 			{
-				name: "_targetIpId",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
 			},
 			{
-				name: "_disputeEvidenceHash",
-				type: "bytes32",
-				internalType: "bytes32"
+				indexed: true,
+				internalType: "address",
+				name: "buyer",
+				type: "address"
 			},
 			{
-				name: "_disputeTag",
-				type: "bytes32",
-				internalType: "bytes32"
-			}
-		],
-		outputs: [
+				indexed: false,
+				internalType: "uint32",
+				name: "periods",
+				type: "uint32"
+			},
 			{
-				name: "id",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: false,
+				internalType: "uint256",
+				name: "newExpiry",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amountPaid",
+				type: "uint256"
 			}
 		],
-		stateMutability: "nonpayable"
-	},
-	{
-		type: "function",
-		name: "renounceOwnership",
-		inputs: [
-		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "AccessPurchased",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "resolveDispute",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "uint256",
+				name: "agentId",
+				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "uint256",
+				name: "ipNftId",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "agentAddress",
+				type: "address"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "AgentRegistered",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "setDisputeQuorum",
+		anonymous: false,
 		inputs: [
 			{
-				name: "_disputeQuorum",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "address",
+				name: "appRegistry",
+				type: "address"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "AppRegistryUpdated",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "stakingThreshold",
+		anonymous: false,
 		inputs: [
-		],
-		outputs: [
 			{
-				name: "",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "uint256",
+				name: "childIp",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "parentIp",
+				type: "uint256"
 			}
 		],
-		stateMutability: "view"
+		name: "ChildIpTagged",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "stakingVault",
+		anonymous: false,
 		inputs: [
-		],
-		outputs: [
 			{
-				name: "",
-				type: "address",
-				internalType: "contract ICampStakingVault"
+				indexed: true,
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "creator",
+				type: "address"
 			}
 		],
-		stateMutability: "view"
+		name: "DataDeleted",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "tagChildIp",
+		anonymous: false,
 		inputs: [
 			{
-				name: "_childIpId",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
 			},
 			{
-				name: "_infringerDisputeId",
-				type: "uint256",
-				internalType: "uint256"
+				indexed: true,
+				internalType: "address",
+				name: "creator",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "contentHash",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256[]",
+				name: "parents",
+				type: "uint256[]"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "DataMinted",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "transferOwnership",
+		anonymous: false,
 		inputs: [
 			{
-				name: "newOwner",
-				type: "address",
-				internalType: "address"
+				indexed: true,
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "counterEvidenceHash",
+				type: "bytes32"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "DisputeAssertion",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "upgradeToAndCall",
+		anonymous: false,
 		inputs: [
 			{
-				name: "newImplementation",
-				type: "address",
-				internalType: "address"
-			},
-			{
-				name: "data",
-				type: "bytes",
-				internalType: "bytes"
+				indexed: true,
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "payable"
+		name: "DisputeCancelled",
+		type: "event"
 	},
 	{
-		type: "function",
-		name: "voteOnDispute",
+		anonymous: false,
 		inputs: [
 			{
+				indexed: true,
+				internalType: "uint256",
 				name: "id",
-				type: "uint256",
-				internalType: "uint256"
+				type: "uint256"
 			},
 			{
-				name: "support",
-				type: "bool",
-				internalType: "bool"
+				indexed: false,
+				internalType: "bool",
+				name: "judgement",
+				type: "bool"
 			}
 		],
-		outputs: [
-		],
-		stateMutability: "nonpayable"
+		name: "DisputeJudged",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "AccessPurchased",
+		anonymous: false,
 		inputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "buyer",
-				type: "address",
 				indexed: true,
-				internalType: "address"
-			},
-			{
-				name: "periods",
-				type: "uint32",
-				indexed: false,
-				internalType: "uint32"
-			},
-			{
-				name: "newExpiry",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
-			},
-			{
-				name: "amountPaid",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
+				internalType: "address",
+				name: "disputeModule",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "DisputeModuleUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "AgentRegistered",
+		anonymous: false,
 		inputs: [
 			{
-				name: "agentId",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
 			},
 			{
-				name: "ipNftId",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "address",
+				name: "initiator",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "uint256",
+				name: "targetId",
+				type: "uint256"
 			},
 			{
-				name: "agentAddress",
-				type: "address",
 				indexed: false,
-				internalType: "address"
+				internalType: "bytes32",
+				name: "disputeTag",
+				type: "bytes32"
 			}
 		],
-		anonymous: false
+		name: "DisputeRaised",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "AppRegistryUpdated",
+		anonymous: false,
 		inputs: [
 			{
-				name: "appRegistry",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				indexed: false,
+				internalType: "uint64",
+				name: "version",
+				type: "uint64"
 			}
 		],
-		anonymous: false
+		name: "Initialized",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "ChildIpTagged",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "childIp",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "parentIp",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
+				internalType: "address",
+				name: "marketPlace",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "MarketPlaceUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DataDeleted",
+		anonymous: false,
 		inputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
 			},
 			{
-				name: "creator",
-				type: "address",
 				indexed: true,
-				internalType: "address"
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "OwnershipTransferred",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DataMinted",
+		anonymous: false,
 		inputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "creator",
-				type: "address",
 				indexed: true,
-				internalType: "address"
+				internalType: "uint256",
+				name: "childIpId",
+				type: "uint256"
 			},
 			{
-				name: "contentHash",
-				type: "bytes32",
 				indexed: false,
-				internalType: "bytes32"
+				internalType: "uint256[]",
+				name: "parentIds",
+				type: "uint256[]"
 			},
 			{
-				name: "parents",
-				type: "uint256[]",
 				indexed: false,
-				internalType: "uint256[]"
+				internalType: "uint16",
+				name: "totalRoyaltyBps",
+				type: "uint16"
 			}
 		],
-		anonymous: false
+		name: "ParentIpsSet",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DisputeAssertion",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "counterEvidenceHash",
-				type: "bytes32",
 				indexed: false,
-				internalType: "bytes32"
+				internalType: "uint16",
+				name: "newFeeBps",
+				type: "uint16"
 			}
 		],
-		anonymous: false
+		name: "ProtocolFeeUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DisputeCancelled",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "royaltyAmount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "creator",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "protocolAmount",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		name: "RoyaltyPaid",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DisputeJudged",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "judgement",
-				type: "bool",
-				indexed: false,
-				internalType: "bool"
+				internalType: "address",
+				name: "signer",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "SignerUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DisputeModuleUpdated",
+		anonymous: false,
 		inputs: [
 			{
-				name: "disputeModule",
-				type: "address",
 				indexed: true,
-				internalType: "address"
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "enum IIpNFT.DataStatus",
+				name: "status",
+				type: "uint8"
 			}
 		],
-		anonymous: false
+		name: "StatusUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "DisputeRaised",
+		anonymous: false,
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "uint256",
+				name: "tokenId",
+				type: "uint256"
 			},
 			{
-				name: "initiator",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				indexed: false,
+				internalType: "uint128",
+				name: "newPrice",
+				type: "uint128"
 			},
 			{
-				name: "targetId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
+				indexed: false,
+				internalType: "uint32",
+				name: "newDuration",
+				type: "uint32"
 			},
 			{
-				name: "disputeTag",
-				type: "bytes32",
 				indexed: false,
-				internalType: "bytes32"
-			}
-		],
-		anonymous: false
-	},
-	{
-		type: "event",
-		name: "Initialized",
-		inputs: [
+				internalType: "uint16",
+				name: "newRoyaltyBps",
+				type: "uint16"
+			},
 			{
-				name: "version",
-				type: "uint64",
 				indexed: false,
-				internalType: "uint64"
+				internalType: "address",
+				name: "paymentToken",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "TermsUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "MarketPlaceUpdated",
+		anonymous: false,
 		inputs: [
 			{
-				name: "marketPlace",
-				type: "address",
 				indexed: true,
-				internalType: "address"
+				internalType: "address",
+				name: "newTreasury",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "TreasuryUpdated",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "OwnershipTransferred",
+		anonymous: false,
 		inputs: [
 			{
-				name: "previousOwner",
-				type: "address",
-				indexed: true,
-				internalType: "address"
-			},
-			{
-				name: "newOwner",
-				type: "address",
 				indexed: true,
-				internalType: "address"
+				internalType: "address",
+				name: "implementation",
+				type: "address"
 			}
 		],
-		anonymous: false
+		name: "Upgraded",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "ParentIpsSet",
+		anonymous: false,
 		inputs: [
 			{
-				name: "childIpId",
-				type: "uint256",
 				indexed: true,
-				internalType: "uint256"
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "voter",
+				type: "address"
 			},
 			{
-				name: "parentIds",
-				type: "uint256[]",
 				indexed: false,
-				internalType: "uint256[]"
+				internalType: "bool",
+				name: "support",
+				type: "bool"
 			},
 			{
-				name: "totalRoyaltyBps",
-				type: "uint16",
 				indexed: false,
-				internalType: "uint16"
+				internalType: "uint256",
+				name: "weight",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		name: "Voted",
+		type: "event"
 	},
 	{
-		type: "event",
-		name: "ProtocolFeeUpdated",
 		inputs: [
+		],
+		name: "UPGRADE_INTERFACE_VERSION",
+		outputs: [
 			{
-				name: "newFeeBps",
-				type: "uint16",
-				indexed: false,
-				internalType: "uint16"
+				internalType: "string",
+				name: "",
+				type: "string"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "RoyaltyPaid",
 		inputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "royaltyAmount",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
-			},
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			}
+		],
+		name: "cancelDispute",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
-				name: "creator",
-				type: "address",
-				indexed: false,
-				internalType: "address"
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
 			},
 			{
-				name: "protocolAmount",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
+				internalType: "bytes32",
+				name: "_counterEvidenceHash",
+				type: "bytes32"
 			}
 		],
-		anonymous: false
+		name: "disputeAssertion",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "SignerUpdated",
 		inputs: [
+		],
+		name: "disputeBond",
+		outputs: [
 			{
-				name: "signer",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "StatusUpdated",
 		inputs: [
+		],
+		name: "disputeCoolDownPeriod",
+		outputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "status",
-				type: "uint8",
-				indexed: false,
-				internalType: "enum IIpNFT.DataStatus"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "TermsUpdated",
 		inputs: [
+		],
+		name: "disputeCounter",
+		outputs: [
 			{
-				name: "tokenId",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
-			},
-			{
-				name: "newPrice",
-				type: "uint128",
-				indexed: false,
-				internalType: "uint128"
-			},
-			{
-				name: "newDuration",
-				type: "uint32",
-				indexed: false,
-				internalType: "uint32"
-			},
-			{
-				name: "newRoyaltyBps",
-				type: "uint16",
-				indexed: false,
-				internalType: "uint16"
-			},
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "disputeJudgementPeriod",
+		outputs: [
 			{
-				name: "paymentToken",
-				type: "address",
-				indexed: false,
-				internalType: "address"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "TreasuryUpdated",
 		inputs: [
+		],
+		name: "disputeQuorum",
+		outputs: [
 			{
-				name: "newTreasury",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "Upgraded",
 		inputs: [
+		],
+		name: "disputeToken",
+		outputs: [
 			{
-				name: "implementation",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				internalType: "contract IERC20",
+				name: "",
+				type: "address"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "event",
-		name: "Voted",
 		inputs: [
 			{
-				name: "id",
-				type: "uint256",
-				indexed: true,
-				internalType: "uint256"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		name: "disputes",
+		outputs: [
+			{
+				internalType: "address",
+				name: "initiator",
+				type: "address"
 			},
 			{
-				name: "voter",
-				type: "address",
-				indexed: true,
-				internalType: "address"
+				internalType: "uint256",
+				name: "targetId",
+				type: "uint256"
 			},
 			{
-				name: "support",
-				type: "bool",
-				indexed: false,
-				internalType: "bool"
+				internalType: "bytes32",
+				name: "disputeTag",
+				type: "bytes32"
 			},
 			{
-				name: "weight",
-				type: "uint256",
-				indexed: false,
-				internalType: "uint256"
+				internalType: "bytes32",
+				name: "disputeEvidenceHash",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "counterEvidenceHash",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256",
+				name: "disputeTimestamp",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "assertionTimestamp",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "yesVotes",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "noVotes",
+				type: "uint256"
+			},
+			{
+				internalType: "enum DisputeModule.DisputeStatus",
+				name: "status",
+				type: "uint8"
+			},
+			{
+				internalType: "uint256",
+				name: "bondAmount",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "protocolFeeAmount",
+				type: "uint256"
 			}
 		],
-		anonymous: false
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "AddressEmptyCode",
 		inputs: [
 			{
-				name: "target",
-				type: "address",
-				internalType: "address"
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
 			}
-		]
-	},
-	{
-		type: "error",
-		name: "AlreadyVoted",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "CoolDownPeriodActive",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "CoolDownPeriodOver",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "ERC1967InvalidImplementation",
-		inputs: [
+		],
+		name: "hasVoted",
+		outputs: [
 			{
-				name: "implementation",
-				type: "address",
-				internalType: "address"
+				internalType: "bool",
+				name: "",
+				type: "bool"
 			}
-		]
-	},
-	{
-		type: "error",
-		name: "ERC1967NonPayable",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "EvidenceAlreadyUsed",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "FailedCall",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "InvalidBondFeeBps",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "InvalidChildIpId",
-		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "InvalidDisputeStatus",
-		inputs: [
-		]
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "InvalidDisputeTag",
 		inputs: [
-		]
+			{
+				internalType: "contract IIpNFT",
+				name: "_ipToken",
+				type: "address"
+			},
+			{
+				internalType: "contract IMarketplace",
+				name: "_marketplace",
+				type: "address"
+			},
+			{
+				internalType: "contract IERC20",
+				name: "_disputeToken",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "_disputeBond",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_disputeCoolDownPeriod",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_disputeJudgementPeriod",
+				type: "uint256"
+			},
+			{
+				internalType: "uint16",
+				name: "_bondFeeBPS",
+				type: "uint16"
+			},
+			{
+				internalType: "uint256",
+				name: "_stakingThreshold",
+				type: "uint256"
+			},
+			{
+				internalType: "contract ICampStakingVault",
+				name: "_stakingVault",
+				type: "address"
+			}
+		],
+		name: "initialize",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "InvalidEvidenceHash",
 		inputs: [
-		]
+		],
+		name: "ipToken",
+		outputs: [
+			{
+				internalType: "contract IIpNFT",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "InvalidInitialization",
 		inputs: [
-		]
-	},
-	{
-		type: "error",
-		name: "InvalidTargetIp",
-		inputs: [
-		]
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		name: "isUsedEvidenceHash",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "NoVotingPower",
 		inputs: [
-		]
+		],
+		name: "marketplace",
+		outputs: [
+			{
+				internalType: "contract IMarketplace",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "NotAParentIp",
 		inputs: [
-		]
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "NotInitializing",
 		inputs: [
-		]
+		],
+		name: "protocolDisputeFee",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "NotInitiator",
 		inputs: [
-		]
+		],
+		name: "proxiableUUID",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "NotTokenOwner",
 		inputs: [
-		]
+			{
+				internalType: "uint256",
+				name: "_targetIpId",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32",
+				name: "_disputeEvidenceHash",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_disputeTag",
+				type: "bytes32"
+			}
+		],
+		name: "raiseDispute",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "OwnableInvalidOwner",
 		inputs: [
-			{
-				name: "owner",
-				type: "address",
-				internalType: "address"
-			}
-		]
+		],
+		name: "renounceOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "OwnableUnauthorizedAccount",
 		inputs: [
 			{
-				name: "account",
-				type: "address",
-				internalType: "address"
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
 			}
-		]
-	},
-	{
-		type: "error",
-		name: "ParentNotDisputed",
-		inputs: [
-		]
+		],
+		name: "resolveDispute",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "SelfAssertionNotAllowed",
 		inputs: [
-		]
+			{
+				internalType: "uint256",
+				name: "_disputeQuorum",
+				type: "uint256"
+			}
+		],
+		name: "setDisputeQuorum",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "StakedAfterDispute",
 		inputs: [
-		]
+		],
+		name: "stakingThreshold",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "TagNotAllowed",
 		inputs: [
-		]
+		],
+		name: "stakingVault",
+		outputs: [
+			{
+				internalType: "contract ICampStakingVault",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "UUPSUnauthorizedCallContext",
 		inputs: [
-		]
+			{
+				internalType: "uint256",
+				name: "_childIpId",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_infringerDisputeId",
+				type: "uint256"
+			}
+		],
+		name: "tagChildIp",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "UUPSUnsupportedProxiableUUID",
 		inputs: [
 			{
-				name: "slot",
-				type: "bytes32",
-				internalType: "bytes32"
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
 			}
-		]
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "VotingPeriodActive",
 		inputs: [
-		]
+			{
+				internalType: "address",
+				name: "newImplementation",
+				type: "address"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "upgradeToAndCall",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
 	},
 	{
-		type: "error",
-		name: "VotingPeriodOver",
 		inputs: [
-		]
+			{
+				internalType: "uint256",
+				name: "id",
+				type: "uint256"
+			},
+			{
+				internalType: "bool",
+				name: "support",
+				type: "bool"
+			}
+		],
+		name: "voteOnDispute",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
 	}
 ];
 
@@ -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,21 +6802,246 @@ 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,
+        });
     });
 }
 
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+function base (ALPHABET) {
+  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET.length; i++) {
+    const x = ALPHABET.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET.length;
+  const LEADER = ALPHABET.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+  const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+  function encode (source) {
+    // eslint-disable-next-line no-empty
+    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+    if (source.length === 0) { return '' }
+    // Skip & count leading zeroes.
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    // Allocate enough space in big-endian base58 representation.
+    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+    const b58 = new Uint8Array(size);
+    // Process the bytes.
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      // Apply "b58 = b58 * 256 + ch".
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+        carry += (256 * b58[it1]) >>> 0;
+        b58[it1] = (carry % BASE) >>> 0;
+        carry = (carry / BASE) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      pbegin++;
+    }
+    // Skip leading zeroes in base58 result.
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    // Translate the result into a string.
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
+    return str
+  }
+  function decodeUnsafe (source) {
+    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+    if (source.length === 0) { return new Uint8Array() }
+    let psz = 0;
+    // Skip and count leading '1's.
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    // Allocate enough space in big-endian base256 representation.
+    const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+    const b256 = new Uint8Array(size);
+    // Process the characters.
+    while (psz < source.length) {
+      // Find code of next character
+      const charCode = source.charCodeAt(psz);
+      // Base map can not be indexed using char code
+      if (charCode > 255) { return }
+      // Decode character
+      let carry = BASE_MAP[charCode];
+      // Invalid character
+      if (carry === 255) { return }
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+        carry += (BASE * b256[it3]) >>> 0;
+        b256[it3] = (carry % 256) >>> 0;
+        carry = (carry / 256) >>> 0;
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i;
+      psz++;
+    }
+    // Skip leading zeroes in b256.
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch
+  }
+  function decode (string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) { return buffer }
+    throw new Error('Non-base' + BASE + ' character')
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  }
+}
+
+var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+var bs58 = base(ALPHABET);
+
+// RFC 4648 base32 alphabet (lowercase)
+const BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+function base32Decode(str) {
+    const lookup = {};
+    for (let i = 0; i < BASE32_ALPHABET.length; i++) {
+        lookup[BASE32_ALPHABET[i]] = i;
+    }
+    let bits = 0;
+    let value = 0;
+    const result = [];
+    for (const char of str.toLowerCase()) {
+        if (!(char in lookup)) {
+            throw new Error(`Invalid base32 character: ${char}`);
+        }
+        value = (value << 5) | lookup[char];
+        bits += 5;
+        if (bits >= 8) {
+            bits -= 8;
+            result.push((value >> bits) & 0xff);
+        }
+    }
+    return new Uint8Array(result);
+}
+/**
+ * Encode a CID to bytes32 by extracting the 32-byte SHA-256 digest.
+ * Supports both CIDv0 (starts with "Qm") and CIDv1 (starts with "bafy").
+ */
+function encodeCidToBytes32(cid) {
+    let digest;
+    if (cid.startsWith("Qm")) {
+        // CIDv0: base58-encoded multihash (0x1220 + 32-byte digest)
+        const decoded = bs58.decode(cid);
+        if (decoded[0] !== 0x12 || decoded[1] !== 0x20 || decoded.length !== 34) {
+            throw new Error("Invalid CIDv0: expected SHA-256 multihash");
+        }
+        digest = decoded.slice(2);
+    }
+    else if (cid.startsWith("b")) {
+        // CIDv1: multibase 'b' prefix + base32-encoded (version + codec + multihash)
+        const decoded = base32Decode(cid.slice(1));
+        // CIDv1 structure: version (1 byte) + codec (varint) + multihash
+        // For raw codec with sha2-256: 0x01 + 0x55 + 0x12 + 0x20 + 32-byte digest
+        // For dag-pb with sha2-256: 0x01 + 0x70 + 0x12 + 0x20 + 32-byte digest
+        if (decoded[0] !== 0x01 || decoded.length !== 36) {
+            throw new Error("Invalid CIDv1: expected version 1 with 36 bytes");
+        }
+        const codec = decoded[1];
+        if (codec !== 0x55 && codec !== 0x70) {
+            throw new Error(`Invalid CIDv1: unsupported codec 0x${codec.toString(16)}`);
+        }
+        if (decoded[2] !== 0x12 || decoded[3] !== 0x20) {
+            throw new Error("Invalid CIDv1: expected SHA-256 hash");
+        }
+        digest = decoded.slice(4);
+    }
+    else {
+        throw new Error("Unsupported CID format: must start with 'Qm' or 'b'");
+    }
+    return `0x${Buffer.from(digest).toString("hex")}`;
+}
+
 /**
  * Raises a dispute with automatic evidence upload to IPFS.
- * Uploads evidence JSON to IPFS, hashes the CID to bytes32 for on-chain storage,
+ * Uploads evidence JSON to IPFS, encodes the CID to bytes32 for on-chain storage,
  * and calls raiseDispute.
  *
+ * The CID is encoded by stripping the 0x1220 multihash prefix from CIDv0,
+ * leaving only the 32-byte SHA-256 digest. This encoding is reversible,
+ * allowing the original CID to be reconstructed from the on-chain data.
+ *
  * @param targetIpId The token ID of the IP NFT to dispute.
  * @param evidence The evidence JSON object to upload to IPFS.
  * @param disputeTag A tag identifying the type of dispute.
@@ -6829,19 +7055,17 @@ function raiseDispute(targetIpId, evidenceHash, disputeTag) {
  *   "0x696e6672696e67656d656e74..." // dispute tag
  * );
  *
- * // Store the CID for evidence retrieval
+ * // The CID can be recovered from evidenceHash using decodeCidFromBytes32
  * console.log("Evidence CID:", result.evidenceCid);
  *
- * // Fetch evidence later via IPFS gateway
+ * // Fetch evidence via IPFS gateway
  * // https://ipfs.io/ipfs/{result.evidenceCid}
- *
- * // Verify evidence hash matches on-chain: keccak256(toHex(evidenceCid)) === evidenceHash
  * ```
  */
 function raiseDisputeSmart(targetIpId, evidence, disputeTag) {
     return __awaiter(this, void 0, void 0, function* () {
         const cid = yield this.uploadJSONToIPFS(evidence);
-        const evidenceHash = keccak256(toHex(cid));
+        const evidenceHash = encodeCidToBytes32(cid);
         const transactionResult = yield this.raiseDispute(targetIpId, evidenceHash, disputeTag);
         return {
             transactionResult,
@@ -6870,6 +7094,48 @@ function disputeAssertion(disputeId, counterEvidenceHash) {
     });
 }
 
+/**
+ * Asserts a dispute with automatic counter-evidence upload to IPFS.
+ * Uploads counter-evidence JSON to IPFS, encodes the CID to bytes32 for on-chain storage,
+ * and calls disputeAssertion.
+ *
+ * The CID is encoded by stripping the 0x1220 multihash prefix from CIDv0,
+ * leaving only the 32-byte SHA-256 digest. This encoding is reversible,
+ * allowing the original CID to be reconstructed from the on-chain data.
+ *
+ * Must be called by the owner of the disputed IP within the cooldown period.
+ *
+ * @param disputeId The ID of the dispute to assert.
+ * @param counterEvidence The counter-evidence JSON object to upload to IPFS.
+ * @returns A promise that resolves with the transaction result, IPFS CID, and counter-evidence hash.
+ *
+ * @example
+ * ```typescript
+ * const result = await origin.disputeAssertionSmart(
+ *   1n,
+ *   { description: "This is my original work", proofUrl: "https://..." }
+ * );
+ *
+ * // The CID can be recovered from counterEvidenceHash using decodeCidFromBytes32
+ * console.log("Counter-evidence CID:", result.counterEvidenceCid);
+ *
+ * // Fetch counter-evidence via IPFS gateway
+ * // https://ipfs.io/ipfs/{result.counterEvidenceCid}
+ * ```
+ */
+function disputeAssertionSmart(disputeId, counterEvidence) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cid = yield this.uploadJSONToIPFS(counterEvidence);
+        const counterEvidenceHash = encodeCidToBytes32(cid);
+        const transactionResult = yield this.disputeAssertion(disputeId, counterEvidenceHash);
+        return {
+            transactionResult,
+            counterEvidenceCid: cid,
+            counterEvidenceHash,
+        };
+    });
+}
+
 /**
  * Votes on a dispute as a CAMP token staker.
  * Only users who staked before the dispute was raised can vote.
@@ -6969,7 +7235,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 +7533,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 +7969,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 +7981,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 +8164,7 @@ function bulkBuyAccessSmart(tokenIds, options) {
                 owner: buyer,
                 spender: this.environment.BATCH_PURCHASE_CONTRACT_ADDRESS,
                 amount: erc20.amount,
+                chain: this.environment.CHAIN,
             });
         }
         // Execute the purchase
@@ -7877,6 +8233,7 @@ class Origin {
         this.raiseDispute = raiseDispute.bind(this);
         this.raiseDisputeSmart = raiseDisputeSmart.bind(this);
         this.disputeAssertion = disputeAssertion.bind(this);
+        this.disputeAssertionSmart = disputeAssertionSmart.bind(this);
         this.voteOnDispute = voteOnDispute.bind(this);
         this.resolveDispute = resolveDispute.bind(this);
         this.cancelDispute = cancelDispute.bind(this);
@@ -7884,6 +8241,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 +8259,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 +8636,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);
         });
@@ -10338,7 +10718,7 @@ const FancyInput = ({ value, onChange, step, placeholder, type = "text", icon, l
  */
 const FileUpload = ({ onFileUpload, accept, maxFileSize, }) => {
     const auth = useAuth();
-    const { environment } = useContext(CampContext);
+    useContext(CampContext);
     const { isAllowListed } = useUser();
     const effectiveMaxFileSize = isAllowListed ? undefined : maxFileSize;
     const [isDragging, setIsDragging] = useState(false);
@@ -10389,11 +10769,7 @@ const FileUpload = ({ onFileUpload, accept, maxFileSize, }) => {
                     : 0; // Duration must be 0 for SINGLE_PAYMENT/X402
                 const priceInWei = parseEther(price || "0");
                 const computedRoyaltyBps = Math.floor(parseFloat(royaltyBps) * 100); // percentage to basis points
-                // Use USDC for X402, native token (zeroAddress) for other license types
-                const paymentToken = licenseType === LicenseType.X402
-                    ? environment.USDC_CONTRACT_ADDRESS
-                    : zeroAddress;
-                const license = createLicenseTerms(priceInWei, durationInSeconds, computedRoyaltyBps, paymentToken, licenseType);
+                const license = createLicenseTerms(priceInWei, durationInSeconds, computedRoyaltyBps, zeroAddress, licenseType);
                 const metadata = {
                     name: selectedFile.name,
                     description: `File uploaded by ${auth === null || auth === void 0 ? void 0 : auth.walletAddress} via the Origin SDK`,