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

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

@@ -5,7 +5,6 @@ import { UseQueryResult } from '@tanstack/react-query';
 interface Environment {
     NAME: string;
     AUTH_HUB_BASE_API: string;
-    AUTH_ENDPOINT: string;
     ORIGIN_DASHBOARD: string;
     DATANFT_CONTRACT_ADDRESS: string;
     MARKETPLACE_CONTRACT_ADDRESS: string;
@@ -13,6 +12,7 @@ interface Environment {
     DISPUTE_CONTRACT_ADDRESS?: string;
     FRACTIONALIZER_CONTRACT_ADDRESS?: string;
     APP_REGISTRY_CONTRACT_ADDRESS?: string;
+    USDC_CONTRACT_ADDRESS: string;
     CHAIN: any;
     IPNFT_ABI?: any;
     MARKETPLACE_ABI?: any;
@@ -130,7 +130,7 @@ type IpNFTSource = "spotify" | "twitter" | "tiktok" | "file";
  * @param licenseTerms The terms of the license for the NFT.
  * @param deadline The deadline for the minting operation.
  * @param signature The signature for the minting operation.
- * @param appId Optional app ID for the minting operation. Defaults to the SDK's appId (clientId).
+ * @param appId Optional app ID for the minting operation.
  * @returns A promise that resolves when the minting is complete.
  */
 declare function mintWithSignature(this: Origin, to: Address, tokenId: bigint, parents: bigint[], isIp: boolean, hash: Hex, uri: string, licenseTerms: LicenseTerms, deadline: bigint, signature: Hex, appId?: string): Promise<any>;
@@ -144,7 +144,7 @@ declare function mintWithSignature(this: Origin, to: Address, tokenId: bigint, p
  * @param parents The IDs of the parent NFTs, if applicable.
  * @return A promise that resolves with the registration data.
  */
-declare function registerIpNFT(this: Origin, source: IpNFTSource, deadline: bigint, licenseTerms: LicenseTerms, metadata: Record<string, unknown>, fileKey?: string | string[], parents?: bigint[]): Promise<any>;
+declare function registerIpNFT(this: Origin, source: IpNFTSource, deadline: bigint, licenseTerms: LicenseTerms, metadata: Record<string, unknown>, isIp: boolean, fileKey?: string | string[], parents?: bigint[], appId?: string): Promise<any>;
 
 /**
  * Updates the license terms of a specified IPNFT.
@@ -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,12 +307,48 @@ 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)
  * );
  * ```
  */
 declare function raiseDispute(this: Origin, targetIpId: bigint, evidenceHash: Hex, disputeTag: Hex): Promise<any>;
 
+interface RaiseDisputeSmartResult {
+    transactionResult: any;
+    evidenceCid: string;
+    evidenceHash: Hex;
+}
+/**
+ * Raises a dispute with automatic evidence upload to IPFS.
+ * 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.
+ * @returns A promise that resolves with the transaction result, IPFS CID, and evidence hash.
+ *
+ * @example
+ * ```typescript
+ * const result = await origin.raiseDisputeSmart(
+ *   1n,
+ *   { reason: "copyright", details: "Unauthorized use of copyrighted material" },
+ *   "0x696e6672696e67656d656e74..." // dispute tag
+ * );
+ *
+ * // The CID can be recovered from evidenceHash using decodeCidFromBytes32
+ * console.log("Evidence CID:", result.evidenceCid);
+ *
+ * // Fetch evidence via IPFS gateway
+ * // https://ipfs.io/ipfs/{result.evidenceCid}
+ * ```
+ */
+declare function raiseDisputeSmart(this: Origin, targetIpId: bigint, evidence: Record<string, any>, disputeTag: Hex): Promise<RaiseDisputeSmartResult>;
+
 /**
  * Asserts a dispute as the IP owner with counter-evidence.
  * Must be called by the owner of the disputed IP within the cooldown period.
@@ -327,6 +364,42 @@ declare function raiseDispute(this: Origin, targetIpId: bigint, evidenceHash: He
  */
 declare function disputeAssertion(this: Origin, disputeId: bigint, counterEvidenceHash: Hex): Promise<any>;
 
+interface DisputeAssertionSmartResult {
+    transactionResult: any;
+    counterEvidenceCid: string;
+    counterEvidenceHash: Hex;
+}
+/**
+ * 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}
+ * ```
+ */
+declare function disputeAssertionSmart(this: Origin, disputeId: bigint, counterEvidence: Record<string, any>): Promise<DisputeAssertionSmartResult>;
+
 /**
  * Votes on a dispute as a CAMP token staker.
  * Only users who staked before the dispute was raised can vote.
@@ -506,6 +579,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.
@@ -865,7 +963,9 @@ declare class Origin {
     buildPurchaseParams: typeof buildPurchaseParams;
     checkActiveStatus: typeof checkActiveStatus;
     raiseDispute: typeof raiseDispute;
+    raiseDisputeSmart: typeof raiseDisputeSmart;
     disputeAssertion: typeof disputeAssertion;
+    disputeAssertionSmart: typeof disputeAssertionSmart;
     voteOnDispute: typeof voteOnDispute;
     resolveDispute: typeof resolveDispute;
     cancelDispute: typeof cancelDispute;
@@ -873,6 +973,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;
@@ -889,6 +990,21 @@ 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.
+     * @returns The CID of the uploaded JSON.
+     * @throws {APIError} If the upload fails.
+     */
+    uploadJSONToIPFS(data: Record<string, any>): Promise<string>;
     /**
      * Mints a file-based IpNFT.
      * @param file The file to mint.
@@ -1032,6 +1148,7 @@ declare class Auth {
     #private;
     redirectUri: Record<string, string>;
     clientId: string;
+    appId: string;
     isAuthenticated: boolean;
     jwt: string | null;
     walletAddress: string | null;
@@ -1049,8 +1166,9 @@ declare class Auth {
      * @param {StorageAdapter} [options.storage] Custom storage adapter. Defaults to localStorage in browser, memory storage in Node.js.
      * @throws {APIError} - Throws an error if the clientId is not provided.
      */
-    constructor({ clientId, redirectUri, environment, baseParentId, storage, }: {
+    constructor({ clientId, appId, redirectUri, environment, baseParentId, storage, }: {
         clientId: string;
+        appId: string;
         redirectUri: string | Record<string, string>;
         environment?: "DEVELOPMENT" | "PRODUCTION";
         baseParentId?: bigint;
@@ -1258,8 +1376,9 @@ declare const CampContext: React.Context<CampContextType>;
  * @param {string} props.environment The environment to use ("DEVELOPMENT" or "PRODUCTION")
  * @returns {JSX.Element} The CampProvider component
  */
-declare const CampProvider: ({ clientId, redirectUri, children, environment, baseParentId, }: {
+declare const CampProvider: ({ clientId, appId, redirectUri, children, environment, baseParentId, }: {
     clientId: string;
+    appId: string;
     redirectUri?: string;
     children: React.ReactNode;
     environment?: "DEVELOPMENT" | "PRODUCTION";