@campnetwork/origin 1.3.2 → 1.4.0-alpha.1

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

@@ -10,17 +10,16 @@ interface Environment {
     MARKETPLACE_CONTRACT_ADDRESS: string;
     BATCH_OPERATIONS_CONTRACT_ADDRESS: string;
     DISPUTE_CONTRACT_ADDRESS?: string;
-    FRACTIONALIZER_CONTRACT_ADDRESS?: string;
     APP_REGISTRY_CONTRACT_ADDRESS?: string;
-    USDC_CONTRACT_ADDRESS: string;
+    IP_ROYALTY_VAULT_FACTORY_CONTRACT_ADDRESS?: string;
     CHAIN: any;
     IPNFT_ABI?: any;
     MARKETPLACE_ABI?: any;
     TBA_ABI?: any;
     BATCH_OPERATIONS_ABI?: any;
     DISPUTE_ABI?: any;
-    FRACTIONALIZER_ABI?: any;
     APP_REGISTRY_ABI?: any;
+    IP_ROYALTY_VAULT_FACTORY_ABI?: any;
 }
 
 /**
@@ -161,14 +160,6 @@ declare function updateTerms(this: Origin, tokenId: bigint, newTerms: LicenseTer
  */
 declare function finalizeDelete(this: Origin, tokenId: bigint): Promise<any>;
 
-/**
- * Calls the getOrCreateRoyaltyVault method on the IPNFT contract.
- * @param tokenOwner The address of the token owner for whom to get or create the royalty vault.
- * @param simulateOnly If true, simulates the transaction without executing it.
- * @returns The address of the royalty vault associated with the specified token owner.
- */
-declare function getOrCreateRoyaltyVault(this: Origin, tokenOwner: Address, simulateOnly?: boolean): Promise<Address>;
-
 /**
  * Returns the license terms associated with a specific token ID.
  * @param tokenId The token ID to query.
@@ -557,182 +548,79 @@ interface DisputeRequirements {
 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.
- * The caller receives the full supply of fractional tokens.
- *
- * @param tokenId The token ID of the IP NFT to fractionalize.
- * @returns A promise that resolves with the transaction result.
- *
- * @example
- * ```typescript
- * // First approve the fractionalizer contract to transfer your NFT
- * await origin.approve(fractionalizerAddress, tokenId);
+ * Gets the royalty vault address for a given token ID.
+ * Returns null if no vault has been deployed yet.
  *
- * // Then fractionalize
- * const result = await origin.fractionalize(1n);
- * ```
+ * @param tokenId The token ID to look up.
+ * @returns The vault address, or null if no vault exists.
  */
-declare function fractionalize(this: Origin, tokenId: bigint): Promise<any>;
+declare function getRoyaltyVault(this: Origin, tokenId: bigint): Promise<Address | null>;
 
 /**
- * Redeems an IP NFT by burning all of its fractional tokens.
- * The caller must hold the entire supply of the NFT's fractional token.
- * After redemption, the NFT is transferred back to the caller.
- *
- * @param tokenId The token ID of the IP NFT to redeem.
- * @returns A promise that resolves with the transaction result.
+ * Gets the list of revenue token addresses that have accumulated in a token's vault.
  *
- * @example
- * ```typescript
- * // Requires holding 100% of the fractional token supply
- * await origin.redeem(1n);
- * ```
+ * @param tokenId The token ID to look up.
+ * @returns An array of ERC20 token addresses with revenue in the vault.
  */
-declare function redeem(this: Origin, tokenId: bigint): Promise<any>;
+declare function getVaultRevenueTokens(this: Origin, tokenId: bigint): Promise<Address[]>;
 
 /**
- * Gets the fractional ERC20 token address for a specific IP NFT.
- * Returns zero address if the NFT has not been fractionalized.
- *
- * @param tokenId The token ID of the IP NFT.
- * @returns A promise that resolves with the fractional token address.
+ * Returns the amount of revenue claimable by a holder for a given token and revenue token.
+ * If no holder is provided, the connected wallet address is used.
  *
- * @example
- * ```typescript
- * const fractionalToken = await origin.getTokenForNFT(1n);
- * if (fractionalToken !== zeroAddress) {
- *   console.log(`Fractional token: ${fractionalToken}`);
- * } else {
- *   console.log("NFT has not been fractionalized");
- * }
- * ```
+ * @param tokenId The token ID whose vault to query.
+ * @param revenueToken The ERC20 revenue token address.
+ * @param holder Optional holder address. Defaults to connected wallet.
+ * @returns The claimable amount in the revenue token's smallest unit.
  */
-declare function getTokenForNFT(this: Origin, tokenId: bigint): Promise<Address>;
+declare function claimableRevenue(this: Origin, tokenId: bigint, revenueToken: Address, holder?: Address): Promise<bigint>;
 
 /**
- * Fractionalizes an IP NFT with automatic approval.
- * This method first approves the fractionalizer contract to transfer your NFT,
- * then calls fractionalize. This is the recommended method for most use cases.
- *
- * @param tokenId The token ID of the IP NFT to fractionalize.
- * @returns A promise that resolves with the transaction result.
+ * Claims accumulated revenue for a token from a specific revenue token.
+ * The caller must hold Royalty Tokens to claim their proportional share.
  *
- * @example
- * ```typescript
- * // Single call handles approval and fractionalization
- * const result = await origin.fractionalizeWithApproval(1n);
- * ```
+ * @param tokenId The token ID whose vault to claim from.
+ * @param revenueToken The ERC20 revenue token address to claim.
+ * @returns The transaction result.
  */
-declare function fractionalizeWithApproval(this: Origin, tokenId: bigint): Promise<any>;
+declare function claimRevenue(this: Origin, tokenId: bigint, revenueToken: Address): Promise<any>;
 
 /**
- * Redeems fractional tokens for the underlying NFT, but only if the caller owns 100% of the supply.
- * This method checks the caller's balance before attempting to redeem, providing a clear error
- * if they don't hold the full supply.
+ * Claims accumulated revenue for a token from multiple revenue tokens in a single transaction.
+ * The caller must hold Royalty Tokens to claim their proportional share.
  *
- * @param tokenId The token ID of the original NFT to redeem.
- * @returns A promise that resolves with the transaction result.
- * @throws Error if the caller doesn't own 100% of the fractional tokens.
- *
- * @example
- * ```typescript
- * try {
- *   const result = await origin.redeemIfComplete(1n);
- *   console.log("NFT redeemed successfully!");
- * } catch (error) {
- *   console.log("You don't own all fractional tokens yet");
- * }
- * ```
+ * @param tokenId The token ID whose vault to claim from.
+ * @param revenueTokens Array of ERC20 revenue token addresses to claim.
+ * @returns The transaction result.
  */
-declare function redeemIfComplete(this: Origin, tokenId: bigint): Promise<any>;
+declare function claimRevenueBatch(this: Origin, tokenId: bigint, revenueTokens: Address[]): Promise<any>;
 
 /**
- * Ownership information for fractional tokens.
+ * Deploys a new royalty vault for an existing NFT that was minted before the vault system.
+ * This is used to migrate old NFTs to the new royalty vault system.
+ *
+ * @param tokenId The token ID to deploy a vault for.
+ * @returns The transaction result including the new vault address.
  */
-interface FractionOwnership {
-    tokenId: bigint;
-    /** The ERC20 token address (zero if not fractionalized) */
-    erc20Address: Address;
-    isFractionalized: boolean;
-    /** User's balance of fractional tokens */
+declare function deployVaultForExistingNFT(this: Origin, tokenId: bigint): Promise<any>;
+
+interface RoyaltyTokenBalance {
+    vaultAddress: Address;
     balance: bigint;
-    /** Total supply of fractional tokens */
     totalSupply: bigint;
-    /** User's ownership percentage (0-100) */
-    ownershipPercentage: number;
-    /** Whether user owns 100% and can redeem */
-    canRedeem: boolean;
+    percentage: number;
     decimals: number;
 }
 /**
- * Gets a user's ownership percentage of a fractionalized NFT.
- * Returns detailed information about the user's fractional token holdings.
- *
- * @param tokenId The token ID of the original NFT.
- * @param owner Optional address to check. If not provided, uses connected wallet.
- * @returns A promise that resolves with the ownership details.
- *
- * @example
- * ```typescript
- * const ownership = await origin.getFractionOwnership(1n);
- *
- * if (!ownership.isFractionalized) {
- *   console.log("This NFT has not been fractionalized");
- * } else {
- *   console.log(`You own ${ownership.ownershipPercentage}% of this NFT`);
- *   console.log(`Balance: ${ownership.balance} / ${ownership.totalSupply}`);
- *
- *   if (ownership.canRedeem) {
- *     console.log("You can redeem the original NFT!");
- *     await origin.redeem(1n);
- *   }
- * }
- * ```
- */
-declare function getFractionOwnership(this: Origin, tokenId: bigint, owner?: Address): Promise<FractionOwnership>;
-
-/**
- * Result of checking if a user can fractionalize an NFT.
- */
-interface FractionalizeEligibility {
-    canFractionalize: boolean;
-    /** Reason why user cannot fractionalize (if canFractionalize is false) */
-    reason?: string;
-    isOwner: boolean;
-    currentOwner: Address;
-    isAlreadyFractionalized: boolean;
-    /** ERC20 address if already fractionalized */
-    existingErc20Address?: Address;
-    dataStatus: DataStatus;
-    isApproved: boolean;
-    needsApproval: boolean;
-}
-/**
- * Checks if a user can fractionalize an NFT and why not if they can't.
- * Returns detailed information about eligibility requirements.
+ * 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.
  *
- * @param tokenId The token ID of the NFT to check.
- * @param owner Optional address to check. If not provided, uses connected wallet.
- * @returns A promise that resolves with the fractionalize eligibility details.
- *
- * @example
- * ```typescript
- * const eligibility = await origin.canFractionalize(1n);
- *
- * if (eligibility.canFractionalize) {
- *   if (eligibility.needsApproval) {
- *     // Use fractionalizeWithApproval for convenience
- *     await origin.fractionalizeWithApproval(1n);
- *   } else {
- *     await origin.fractionalize(1n);
- *   }
- * } else {
- *   console.log(`Cannot fractionalize: ${eligibility.reason}`);
- * }
- * ```
+ * @param tokenId The token ID whose vault to query.
+ * @param holder Optional holder address. Defaults to the NFT's TBA.
+ * @returns The royalty token balance info including vault address, balance, total supply, percentage, and decimals.
  */
-declare function canFractionalize(this: Origin, tokenId: bigint, owner?: Address): Promise<FractionalizeEligibility>;
+declare function getRoyaltyTokenBalance(this: Origin, tokenId: bigint, holder?: Address): Promise<RoyaltyTokenBalance>;
 
 /**
  * Gets information about a registered app from the AppRegistry.
@@ -959,7 +847,6 @@ declare class Origin {
     registerIpNFT: typeof registerIpNFT;
     updateTerms: typeof updateTerms;
     finalizeDelete: typeof finalizeDelete;
-    getOrCreateRoyaltyVault: typeof getOrCreateRoyaltyVault;
     getTerms: typeof getTerms;
     ownerOf: typeof ownerOf;
     balanceOf: typeof balanceOf;
@@ -993,13 +880,13 @@ declare class Origin {
     canVoteOnDispute: typeof canVoteOnDispute;
     getDisputeProgress: typeof getDisputeProgress;
     getDisputeRequirements: typeof getDisputeRequirements;
-    fractionalize: typeof fractionalize;
-    redeem: typeof redeem;
-    getTokenForNFT: typeof getTokenForNFT;
-    fractionalizeWithApproval: typeof fractionalizeWithApproval;
-    redeemIfComplete: typeof redeemIfComplete;
-    getFractionOwnership: typeof getFractionOwnership;
-    canFractionalize: typeof canFractionalize;
+    getRoyaltyVault: typeof getRoyaltyVault;
+    getVaultRevenueTokens: typeof getVaultRevenueTokens;
+    claimableRevenue: typeof claimableRevenue;
+    claimRevenue: typeof claimRevenue;
+    claimRevenueBatch: typeof claimRevenueBatch;
+    deployVaultForExistingNFT: typeof deployVaultForExistingNFT;
+    getRoyaltyTokenBalance: typeof getRoyaltyTokenBalance;
     getAppInfo: typeof getAppInfo;
     private jwt?;
     environment: Environment;