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

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

@@ -1,5 +1,5 @@
 import React, { JSX } from 'react';
-import { Address, Hex, Abi } from 'viem';
+import { Address, Hex, WalletClient, Abi } from 'viem';
 import { UseQueryResult } from '@tanstack/react-query';
 
 interface Environment {
@@ -12,6 +12,7 @@ interface Environment {
     CHAIN: any;
     IPNFT_ABI?: any;
     MARKETPLACE_ABI?: any;
+    ROYALTY_VAULT_ABI?: any;
 }
 
 /**
@@ -66,26 +67,70 @@ declare function mintWithSignature(this: Origin, to: Address, tokenId: bigint, p
  */
 declare function registerIpNFT(this: Origin, source: IpNFTSource, deadline: bigint, licenseTerms: LicenseTerms, metadata: Record<string, unknown>, fileKey?: string | string[], parents?: bigint[]): Promise<any>;
 
-declare function updateTerms(this: Origin, tokenId: bigint, royaltyReceiver: Address, newTerms: LicenseTerms): Promise<any>;
+/**
+ * Updates the license terms of a specified IPNFT.
+ * @param tokenId The ID of the IPNFT to update.
+ * @param newTerms The new license terms to set.
+ * @returns A promise that resolves when the transaction is complete.
+ */
+declare function updateTerms(this: Origin, tokenId: bigint, newTerms: LicenseTerms): Promise<any>;
 
-declare function requestDelete(this: Origin, tokenId: bigint): Promise<any>;
+/**
+ * Sets the IPNFT as deleted
+ * @param tokenId The token ID to set as deleted.
+ * @returns A promise that resolves when the transaction is complete.
+ */
+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.
+ * @returns The license terms of the token ID.
+ */
 declare function getTerms(this: Origin, tokenId: bigint): Promise<any>;
 
+/**
+ * Returns the owner of the specified IPNFT.
+ * @param tokenId The ID of the IPNFT to query.
+ * @returns The address of the owner of the IPNFT.
+ */
 declare function ownerOf(this: Origin, tokenId: bigint): Promise<any>;
 
+/**
+ * Returns the number of IPNFTs owned by the given address.
+ * @param owner The address to query.
+ * @returns The number of IPNFTs owned by the address.
+ */
 declare function balanceOf(this: Origin, owner: Address): Promise<any>;
 
-declare function contentHash(this: Origin, tokenId: bigint): Promise<any>;
-
+/**
+ * Returns the metadata URI associated with a specific token ID.
+ * @param tokenId The token ID to query.
+ * @returns The metadata URI of the token ID.
+ */
 declare function tokenURI(this: Origin, tokenId: bigint): Promise<any>;
 
+/**
+ * Returns the data status of the given token ID.
+ * @param tokenId The token ID to query.
+ * @returns The data status of the token ID.
+ */
 declare function dataStatus(this: Origin, tokenId: bigint): Promise<DataStatus>;
 
-declare function royaltyInfo(this: Origin, tokenId: bigint, salePrice: bigint): Promise<[Address, bigint]>;
-
-declare function getApproved(this: Origin, tokenId: bigint): Promise<Address>;
-
+/**
+ * Checks if an operator is approved to manage all assets of a given owner.
+ * @param owner The address of the asset owner.
+ * @param operator The address of the operator to check.
+ * @return A promise that resolves to a boolean indicating if the operator is approved for all assets of the owner.
+ */
 declare function isApprovedForAll(this: Origin, owner: Address, operator: Address): Promise<boolean>;
 
 declare function transferFrom(this: Origin, from: Address, to: Address, tokenId: bigint): Promise<any>;
@@ -96,10 +141,24 @@ declare function approve(this: Origin, to: Address, tokenId: bigint): Promise<an
 
 declare function setApprovalForAll(this: Origin, operator: Address, approved: boolean): Promise<any>;
 
-declare function buyAccess(this: Origin, buyer: Address, tokenId: bigint, periods: number, value?: bigint): Promise<any>;
-
-declare function renewAccess(this: Origin, tokenId: bigint, buyer: Address, periods: number, value?: bigint): Promise<any>;
+/**
+ * Buys access to a data NFT for a specified duration.
+ * @param buyer The address of the buyer.
+ * @param tokenId The ID of the data NFT.
+ * @param expectedPrice The expected price for the access.
+ * @param expectedDuration The expected duration of the access in seconds.
+ * @param expectedPaymentToken The address of the payment token (use zero address for native token).
+ * @param value The amount of native token to send (only required if paying with native token).
+ * @returns A promise that resolves when the transaction is confirmed.
+ */
+declare function buyAccess(this: Origin, buyer: Address, tokenId: bigint, expectedPrice: bigint, expectedDuration: bigint, expectedPaymentToken: Address, value?: bigint): Promise<any>;
 
+/**
+ * Checks if a user has access to a specific token based on subscription expiry.
+ * @param user - The address of the user.
+ * @param tokenId - The ID of the token.
+ * @returns A promise that resolves to a boolean indicating if the user has access.
+ */
 declare function hasAccess(this: Origin, user: Address, tokenId: bigint): Promise<boolean>;
 
 declare function subscriptionExpiry(this: Origin, tokenId: bigint, user: Address): Promise<bigint>;
@@ -113,10 +172,16 @@ interface OriginUsageReturnType {
     teams: Array<any>;
     dataSources: Array<any>;
 }
+interface RoyaltyInfo {
+    royaltyVault: Address;
+    balance: bigint;
+    balanceFormatted: string;
+}
 type CallOptions = {
     value?: bigint;
     gas?: bigint;
     waitForReceipt?: boolean;
+    simulate?: boolean;
 };
 /**
  * The Origin class
@@ -127,38 +192,35 @@ declare class Origin {
     mintWithSignature: typeof mintWithSignature;
     registerIpNFT: typeof registerIpNFT;
     updateTerms: typeof updateTerms;
-    requestDelete: typeof requestDelete;
+    finalizeDelete: typeof finalizeDelete;
+    getOrCreateRoyaltyVault: typeof getOrCreateRoyaltyVault;
     getTerms: typeof getTerms;
     ownerOf: typeof ownerOf;
     balanceOf: typeof balanceOf;
-    contentHash: typeof contentHash;
     tokenURI: typeof tokenURI;
     dataStatus: typeof dataStatus;
-    royaltyInfo: typeof royaltyInfo;
-    getApproved: typeof getApproved;
     isApprovedForAll: typeof isApprovedForAll;
     transferFrom: typeof transferFrom;
     safeTransferFrom: typeof safeTransferFrom;
     approve: typeof approve;
     setApprovalForAll: typeof setApprovalForAll;
     buyAccess: typeof buyAccess;
-    renewAccess: typeof renewAccess;
     hasAccess: typeof hasAccess;
     subscriptionExpiry: typeof subscriptionExpiry;
     private jwt;
     environment: Environment;
     private viemClient?;
-    constructor(jwt: string, environment: Environment, viemClient?: any);
+    constructor(jwt: string, environment: Environment, viemClient?: WalletClient);
     getJwt(): string;
-    setViemClient(client: any): void;
-    uploadFile: (file: File, options?: {
+    setViemClient(client: WalletClient): void;
+    uploadFile(file: File, options?: {
         progressCallback?: (percent: number) => void;
-    }) => Promise<any>;
-    mintFile: (file: File, metadata: Record<string, unknown>, license: LicenseTerms, parents?: bigint[], options?: {
+    }): Promise<any>;
+    mintFile(file: File, metadata: Record<string, unknown>, license: LicenseTerms, parents?: bigint[], options?: {
         progressCallback?: (percent: number) => void;
-    }) => Promise<string | null>;
-    mintSocial: (source: "spotify" | "twitter" | "tiktok", metadata: Record<string, unknown>, license: LicenseTerms) => Promise<string | null>;
-    getOriginUploads: () => Promise<any>;
+    }): Promise<string | null>;
+    mintSocial(source: "spotify" | "twitter" | "tiktok", metadata: Record<string, unknown>, license: LicenseTerms): Promise<string | null>;
+    getOriginUploads(): Promise<any[] | null>;
     /**
      * Get the user's Origin stats (multiplier, consent, usage, etc.).
      * @returns {Promise<OriginUsageReturnType>} A promise that resolves with the user's Origin stats.
@@ -171,13 +233,6 @@ declare class Origin {
      * @throws {Error|APIError} - Throws an error if the user is not authenticated. Also throws an error if the consent is not provided.
      */
     setOriginConsent(consent: boolean): Promise<void>;
-    /**
-     * Set the user's Origin multiplier.
-     * @param {number} multiplier The user's Origin multiplier.
-     * @returns {Promise<void>}
-     * @throws {Error|APIError} - Throws an error if the user is not authenticated. Also throws an error if the multiplier is not provided.
-     */
-    setOriginMultiplier(multiplier: number): Promise<void>;
     /**
      * Call a contract method.
      * @param {string} contractAddress The contract address.
@@ -192,11 +247,33 @@ declare class Origin {
     /**
      * Buy access to an asset by first checking its price via getTerms, then calling buyAccess.
      * @param {bigint} tokenId The token ID of the asset.
-     * @param {number} periods The number of periods to buy access for.
      * @returns {Promise<any>} The result of the buyAccess call.
      */
-    buyAccessSmart(tokenId: bigint, periods: number): Promise<any>;
+    buyAccessSmart(tokenId: bigint): Promise<any>;
     getData(tokenId: bigint): Promise<any>;
+    /**
+     * Get royalty information for a wallet address, including the royalty vault address and its balance.
+     * @param {Address} [owner] - Optional wallet address to check royalties for. If not provided, uses the connected wallet.
+     * @returns {Promise<RoyaltyInfo>} A promise that resolves with the royalty vault address and balance information.
+     * @throws {Error} Throws an error if no wallet is connected and no owner address is provided.
+     * @example
+     * ```typescript
+     * // Get royalties for connected wallet
+     * const royalties = await origin.getRoyalties();
+     *
+     * // Get royalties for specific address
+     * const royalties = await origin.getRoyalties("0x1234...");
+     * ```
+     */
+    getRoyalties(token?: Address, owner?: Address): Promise<RoyaltyInfo>;
+    /**
+     * Claim royalties from the royalty vault.
+     * @param {Address} [token] - Optional token address to claim royalties in. If not provided, claims in native token.
+     * @param {Address} [owner] - Optional wallet address to claim royalties for. If not provided, uses the connected wallet.
+     * @returns {Promise<any>} A promise that resolves when the claim transaction is confirmed.
+     * @throws {Error} Throws an error if no wallet is connected and no owner address is provided.
+     */
+    claimRoyalties(token?: Address, owner?: Address): Promise<any>;
 }
 
 declare global {