@story-protocol/core-sdk 1.0.0-rc.11 → 1.0.0-rc.13

package/README.md

@@ -42,7 +42,7 @@ The SDK supports using `viem` for initiating SDK client. Create a typescript fil
 import { privateKeyToAccount } from "viem/accounts";
 
 const WALLET_PRIVATE_KEY = process.env.WALLET_PRIVATE_KEY || "0x";
-const account = privateKeyToAccount(WALLET_PRIVATE_KEY as `0x${string}`);
+const account = privateKeyToAccount(WALLET_PRIVATE_KEY as Address);
 ```
 
 The preceding code created the `account` object for creating the SDK client.
@@ -100,9 +100,7 @@ In your testing environment:
 
 ## Steps to pull and compile latest smart contract ABIs (Currently pulls from the protocol-contracts `dev` branch)
 
-Must have `solc` installed (https://docs.soliditylang.org/en/v0.8.9/installing-solidity.html)
-
-- run `make compile_contracts`
+- run `cd packages/wagmi-generator && npm run generate`
 
 ## Release
 

package/dist/declarations/src/abi/generated.d.ts

@@ -17192,11 +17192,11 @@ export declare const spgAbi: readonly [{
         readonly internalType: "uint32";
         readonly type: "uint32";
     }, {
-        readonly name: "mintCost";
+        readonly name: "mintFee";
         readonly internalType: "uint256";
         readonly type: "uint256";
     }, {
-        readonly name: "mintToken";
+        readonly name: "mintFeeToken";
         readonly internalType: "address";
         readonly type: "address";
     }, {
@@ -17503,6 +17503,58 @@ export declare const spgAbi: readonly [{
         readonly type: "bytes32";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "nftContract";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "metadata";
+        readonly internalType: "struct IStoryProtocolGateway.IPMetadata";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "metadataURI";
+            readonly internalType: "string";
+            readonly type: "string";
+        }, {
+            readonly name: "metadataHash";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "nftMetadataHash";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }];
+    }, {
+        readonly name: "sigMetadata";
+        readonly internalType: "struct IStoryProtocolGateway.SignatureData";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "signer";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "deadline";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "signature";
+            readonly internalType: "bytes";
+            readonly type: "bytes";
+        }];
+    }];
+    readonly name: "registerIp";
+    readonly outputs: readonly [{
+        readonly name: "ipId";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -18208,11 +18260,11 @@ export declare const spgConfig: {
             readonly internalType: "uint32";
             readonly type: "uint32";
         }, {
-            readonly name: "mintCost";
+            readonly name: "mintFee";
             readonly internalType: "uint256";
             readonly type: "uint256";
         }, {
-            readonly name: "mintToken";
+            readonly name: "mintFeeToken";
             readonly internalType: "address";
             readonly type: "address";
         }, {
@@ -18519,6 +18571,58 @@ export declare const spgConfig: {
             readonly type: "bytes32";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly inputs: readonly [{
+            readonly name: "nftContract";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenId";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "metadata";
+            readonly internalType: "struct IStoryProtocolGateway.IPMetadata";
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly name: "metadataURI";
+                readonly internalType: "string";
+                readonly type: "string";
+            }, {
+                readonly name: "metadataHash";
+                readonly internalType: "bytes32";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "nftMetadataHash";
+                readonly internalType: "bytes32";
+                readonly type: "bytes32";
+            }];
+        }, {
+            readonly name: "sigMetadata";
+            readonly internalType: "struct IStoryProtocolGateway.SignatureData";
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly name: "signer";
+                readonly internalType: "address";
+                readonly type: "address";
+            }, {
+                readonly name: "deadline";
+                readonly internalType: "uint256";
+                readonly type: "uint256";
+            }, {
+                readonly name: "signature";
+                readonly internalType: "bytes";
+                readonly type: "bytes";
+            }];
+        }];
+        readonly name: "registerIp";
+        readonly outputs: readonly [{
+            readonly name: "ipId";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly inputs: readonly [{
@@ -20575,6 +20679,32 @@ export type AccessControllerPermissionSetEvent = {
     func: Hex;
     permission: number;
 };
+/**
+ * AccessControllerSetAllPermissionsRequest
+ *
+ * @param ipAccount address
+ * @param signer address
+ * @param permission uint8
+ */
+export type AccessControllerSetAllPermissionsRequest = {
+    ipAccount: Address;
+    signer: Address;
+    permission: number;
+};
+/**
+ * AccessControllerSetBatchPermissionsRequest
+ *
+ * @param permissions tuple[]
+ */
+export type AccessControllerSetBatchPermissionsRequest = {
+    permissions: {
+        ipAccount: Address;
+        signer: Address;
+        to: Address;
+        func: Hex;
+        permission: number;
+    }[];
+};
 /**
  * AccessControllerSetPermissionRequest
  *
@@ -20613,6 +20743,20 @@ export declare class AccessControllerEventClient {
 export declare class AccessControllerClient extends AccessControllerEventClient {
     protected readonly wallet: SimpleWalletClient;
     constructor(rpcClient: PublicClient, wallet: SimpleWalletClient, address?: Address);
+    /**
+     * method setAllPermissions for contract AccessController
+     *
+     * @param request AccessControllerSetAllPermissionsRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    setAllPermissions(request: AccessControllerSetAllPermissionsRequest): Promise<WriteContractReturnType>;
+    /**
+     * method setBatchPermissions for contract AccessController
+     *
+     * @param request AccessControllerSetBatchPermissionsRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    setBatchPermissions(request: AccessControllerSetBatchPermissionsRequest): Promise<WriteContractReturnType>;
     /**
      * method setPermission for contract AccessController
      *
@@ -20621,6 +20765,67 @@ export declare class AccessControllerClient extends AccessControllerEventClient
      */
     setPermission(request: AccessControllerSetPermissionRequest): Promise<WriteContractReturnType>;
 }
+/**
+ * CoreMetadataModuleMetadataFrozenEvent
+ *
+ * @param ipId address
+ */
+export type CoreMetadataModuleMetadataFrozenEvent = {
+    ipId: Address;
+};
+/**
+ * CoreMetadataModuleMetadataUriSetEvent
+ *
+ * @param ipId address
+ * @param metadataURI string
+ * @param metadataHash bytes32
+ */
+export type CoreMetadataModuleMetadataUriSetEvent = {
+    ipId: Address;
+    metadataURI: string;
+    metadataHash: Hex;
+};
+/**
+ * CoreMetadataModuleNftTokenUriSetEvent
+ *
+ * @param ipId address
+ * @param nftTokenURI string
+ * @param nftMetadataHash bytes32
+ */
+export type CoreMetadataModuleNftTokenUriSetEvent = {
+    ipId: Address;
+    nftTokenURI: string;
+    nftMetadataHash: Hex;
+};
+export type CoreMetadataModuleAccessControllerResponse = Address;
+export type CoreMetadataModuleIpAccountRegistryResponse = Address;
+/**
+ * CoreMetadataModuleIsMetadataFrozenRequest
+ *
+ * @param ipId address
+ */
+export type CoreMetadataModuleIsMetadataFrozenRequest = {
+    ipId: Address;
+};
+export type CoreMetadataModuleIsMetadataFrozenResponse = boolean;
+export type CoreMetadataModuleNameResponse = string;
+/**
+ * CoreMetadataModuleSupportsInterfaceRequest
+ *
+ * @param interfaceId bytes4
+ */
+export type CoreMetadataModuleSupportsInterfaceRequest = {
+    interfaceId: Hex;
+};
+export type CoreMetadataModuleSupportsInterfaceResponse = boolean;
+/**
+ * CoreMetadataModuleFreezeMetadataRequest
+ *
+ * @param ipId address
+ */
+export type CoreMetadataModuleFreezeMetadataRequest = {
+    ipId: Address;
+};
 /**
  * CoreMetadataModuleSetAllRequest
  *
@@ -20636,13 +20841,113 @@ export type CoreMetadataModuleSetAllRequest = {
     nftMetadataHash: Hex;
 };
 /**
- * contract CoreMetadataModule write method
+ * CoreMetadataModuleSetMetadataUriRequest
+ *
+ * @param ipId address
+ * @param metadataURI string
+ * @param metadataHash bytes32
  */
-export declare class CoreMetadataModuleClient {
-    protected readonly wallet: SimpleWalletClient;
+export type CoreMetadataModuleSetMetadataUriRequest = {
+    ipId: Address;
+    metadataURI: string;
+    metadataHash: Hex;
+};
+/**
+ * CoreMetadataModuleUpdateNftTokenUriRequest
+ *
+ * @param ipId address
+ * @param nftMetadataHash bytes32
+ */
+export type CoreMetadataModuleUpdateNftTokenUriRequest = {
+    ipId: Address;
+    nftMetadataHash: Hex;
+};
+/**
+ * contract CoreMetadataModule event
+ */
+export declare class CoreMetadataModuleEventClient {
     protected readonly rpcClient: PublicClient;
     readonly address: Address;
+    constructor(rpcClient: PublicClient, address?: Address);
+    /**
+     * event MetadataFrozen for contract CoreMetadataModule
+     */
+    watchMetadataFrozenEvent(onLogs: (txHash: Hex, ev: Partial<CoreMetadataModuleMetadataFrozenEvent>) => void): WatchContractEventReturnType;
+    /**
+     * parse tx receipt event MetadataFrozen for contract CoreMetadataModule
+     */
+    parseTxMetadataFrozenEvent(txReceipt: TransactionReceipt): Array<CoreMetadataModuleMetadataFrozenEvent>;
+    /**
+     * event MetadataURISet for contract CoreMetadataModule
+     */
+    watchMetadataUriSetEvent(onLogs: (txHash: Hex, ev: Partial<CoreMetadataModuleMetadataUriSetEvent>) => void): WatchContractEventReturnType;
+    /**
+     * parse tx receipt event MetadataURISet for contract CoreMetadataModule
+     */
+    parseTxMetadataUriSetEvent(txReceipt: TransactionReceipt): Array<CoreMetadataModuleMetadataUriSetEvent>;
+    /**
+     * event NFTTokenURISet for contract CoreMetadataModule
+     */
+    watchNftTokenUriSetEvent(onLogs: (txHash: Hex, ev: Partial<CoreMetadataModuleNftTokenUriSetEvent>) => void): WatchContractEventReturnType;
+    /**
+     * parse tx receipt event NFTTokenURISet for contract CoreMetadataModule
+     */
+    parseTxNftTokenUriSetEvent(txReceipt: TransactionReceipt): Array<CoreMetadataModuleNftTokenUriSetEvent>;
+}
+/**
+ * contract CoreMetadataModule readonly method
+ */
+export declare class CoreMetadataModuleReadOnlyClient extends CoreMetadataModuleEventClient {
+    constructor(rpcClient: PublicClient, address?: Address);
+    /**
+     * method ACCESS_CONTROLLER for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleAccessControllerRequest
+     * @return Promise<CoreMetadataModuleAccessControllerResponse>
+     */
+    accessController(): Promise<CoreMetadataModuleAccessControllerResponse>;
+    /**
+     * method IP_ACCOUNT_REGISTRY for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleIpAccountRegistryRequest
+     * @return Promise<CoreMetadataModuleIpAccountRegistryResponse>
+     */
+    ipAccountRegistry(): Promise<CoreMetadataModuleIpAccountRegistryResponse>;
+    /**
+     * method isMetadataFrozen for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleIsMetadataFrozenRequest
+     * @return Promise<CoreMetadataModuleIsMetadataFrozenResponse>
+     */
+    isMetadataFrozen(request: CoreMetadataModuleIsMetadataFrozenRequest): Promise<CoreMetadataModuleIsMetadataFrozenResponse>;
+    /**
+     * method name for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleNameRequest
+     * @return Promise<CoreMetadataModuleNameResponse>
+     */
+    name(): Promise<CoreMetadataModuleNameResponse>;
+    /**
+     * method supportsInterface for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleSupportsInterfaceRequest
+     * @return Promise<CoreMetadataModuleSupportsInterfaceResponse>
+     */
+    supportsInterface(request: CoreMetadataModuleSupportsInterfaceRequest): Promise<CoreMetadataModuleSupportsInterfaceResponse>;
+}
+/**
+ * contract CoreMetadataModule write method
+ */
+export declare class CoreMetadataModuleClient extends CoreMetadataModuleReadOnlyClient {
+    protected readonly wallet: SimpleWalletClient;
     constructor(rpcClient: PublicClient, wallet: SimpleWalletClient, address?: Address);
+    /**
+     * method freezeMetadata for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleFreezeMetadataRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    freezeMetadata(request: CoreMetadataModuleFreezeMetadataRequest): Promise<WriteContractReturnType>;
     /**
      * method setAll for contract CoreMetadataModule
      *
@@ -20650,6 +20955,20 @@ export declare class CoreMetadataModuleClient {
      * @return Promise<WriteContractReturnType>
      */
     setAll(request: CoreMetadataModuleSetAllRequest): Promise<WriteContractReturnType>;
+    /**
+     * method setMetadataURI for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleSetMetadataUriRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    setMetadataUri(request: CoreMetadataModuleSetMetadataUriRequest): Promise<WriteContractReturnType>;
+    /**
+     * method updateNftTokenURI for contract CoreMetadataModule
+     *
+     * @param request CoreMetadataModuleUpdateNftTokenUriRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    updateNftTokenUri(request: CoreMetadataModuleUpdateNftTokenUriRequest): Promise<WriteContractReturnType>;
 }
 /**
  * DisputeModuleDisputeCancelledEvent
@@ -22797,16 +23116,16 @@ export type SpgCollectionCreatedEvent = {
  * @param name string
  * @param symbol string
  * @param maxSupply uint32
- * @param mintCost uint256
- * @param mintToken address
+ * @param mintFee uint256
+ * @param mintFeeToken address
  * @param owner address
  */
 export type SpgCreateCollectionRequest = {
     name: string;
     symbol: string;
     maxSupply: number;
-    mintCost: bigint;
-    mintToken: Address;
+    mintFee: bigint;
+    mintFeeToken: Address;
     owner: Address;
 };
 /**
@@ -22904,6 +23223,28 @@ export type SpgMintAndRegisterIpAndMakeDerivativeWithLicenseTokensRequest = {
     };
     recipient: Address;
 };
+/**
+ * SpgRegisterIpRequest
+ *
+ * @param nftContract address
+ * @param tokenId uint256
+ * @param metadata tuple
+ * @param sigMetadata tuple
+ */
+export type SpgRegisterIpRequest = {
+    nftContract: Address;
+    tokenId: bigint;
+    metadata: {
+        metadataURI: string;
+        metadataHash: Hex;
+        nftMetadataHash: Hex;
+    };
+    sigMetadata: {
+        signer: Address;
+        deadline: bigint;
+        signature: Hex;
+    };
+};
 /**
  * SpgRegisterIpAndAttachPilTermsRequest
  *
@@ -23104,6 +23445,13 @@ export declare class SpgClient extends SpgEventClient {
      * @return Promise<WriteContractReturnType>
      */
     mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(request: SpgMintAndRegisterIpAndMakeDerivativeWithLicenseTokensRequest): Promise<WriteContractReturnType>;
+    /**
+     * method registerIp for contract SPG
+     *
+     * @param request SpgRegisterIpRequest
+     * @return Promise<WriteContractReturnType>
+     */
+    registerIp(request: SpgRegisterIpRequest): Promise<WriteContractReturnType>;
     /**
      * method registerIpAndAttachPILTerms for contract SPG
      *