signet.js 0.0.12-beta.13 → 0.0.12-beta.17

package/types/index.d.ts

@@ -33,11 +33,13 @@ declare abstract class BaseChainSignatureContract {
      * @param args - Arguments for key derivation
      * @param args.path - The string path to use derive the key
      * @param args.predecessor - The id/address of the account requesting signature
+     * @param args.keyVersion - Optional key version controlling the derivation prefix (defaults to 0)
      * @returns Promise resolving to the derived SEC1 uncompressed public key
      */
     abstract getDerivedPublicKey(args: {
         path: string;
         predecessor: string;
+        keyVersion: number;
     } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
 }
 /**
@@ -105,8 +107,8 @@ declare const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey>;
  * @see {@link deriveChildPublicKey} in cryptography.ts for usage details
  */
 declare const KDF_CHAIN_IDS: {
-    readonly ETHEREUM: "0x1";
-    readonly SOLANA: "0x800001f5";
+    readonly ETHEREUM: "eip155:1";
+    readonly SOLANA: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 };
 /**
  * Contract addresses for different chains and environments.
@@ -147,15 +149,17 @@ declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) =
  */
 declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => UncompressedPubKeySEC1;
 /**
- * Derives a child public key from a parent public key using the sig.network v1.0.0 epsilon derivation scheme.
+ * Derives a child public key from a parent public key using the Sig.Network epsilon derivation scheme.
  * The parent public keys are defined in @constants.ts
  *
- * @param najPublicKey - The parent public key in uncompressed SEC1 format (e.g. 04 || x || y)
+ * @param rootUncompressedPubKeySEC1 - The parent public key in uncompressed SEC1 format (e.g. 04 || x || y)
  * @param predecessorId - The predecessor ID is the address of the account calling the signer contract (e.g EOA or Contract Address)
  * @param path - Optional derivation path suffix (defaults to empty string)
+ * @param chainId - CAIP-2 chain identifier used for derivation
+ * @param keyVersion - Key version controlling which derivation prefix to use (legacy v1 for 0, CAIP-2 v2 otherwise)
  * @returns The derived child public key in uncompressed SEC1 format (04 || x || y)
  */
-declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string): UncompressedPubKeySEC1;
+declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, keyVersion: number): UncompressedPubKeySEC1;
 /**
  * Verifies that a secp256k1 signature was created by the expected derived address
  * by recovering the signing address and comparing it with the address derived from the contract.
@@ -167,7 +171,7 @@ declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPu
  * @param contract - The contract instance for deriving addresses
  * @returns Promise resolving to true if the recovered address matches the expected address
  */
-declare function verifyRecoveredAddress(signature: RSVSignature, payload: number[] | Uint8Array, requesterAddress: string, path: string, contract: BaseChainSignatureContract): Promise<boolean>;
+declare function verifyRecoveredAddress(signature: RSVSignature, payload: number[] | Uint8Array, requesterAddress: string, path: string, contract: BaseChainSignatureContract, keyVersion: number): Promise<boolean>;
 
 declare const cryptography_compressPubKey: typeof compressPubKey;
 declare const cryptography_deriveChildPublicKey: typeof deriveChildPublicKey;
@@ -203,7 +207,7 @@ declare abstract class ChainAdapter<TransactionRequest, UnsignedTransaction> {
      * @param path - The string path used to derive the key
      * @returns Promise resolving to the derived address and public key
      */
-    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
         address: string;
         publicKey: string;
     }>;
@@ -323,7 +327,7 @@ declare class EVM extends ChainAdapter<EVMTransactionRequest, EVMUnsignedTransac
     private attachGasAndNonce;
     private transformRSVSignature;
     private assembleSignature;
-    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
         address: string;
         publicKey: string;
     }>;
@@ -507,7 +511,7 @@ declare class Bitcoin extends ChainAdapter<BTCTransactionRequest, BTCUnsignedTra
         balance: bigint;
         decimals: number;
     }>;
-    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
         address: string;
         publicKey: string;
     }>;
@@ -581,7 +585,7 @@ declare class Cosmos extends ChainAdapter<CosmosTransactionRequest, CosmosUnsign
         balance: bigint;
         decimals: number;
     }>;
-    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
         address: string;
         publicKey: string;
     }>;
@@ -804,6 +808,7 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
     getDerivedPublicKey(args: {
         path: string;
         predecessor: string;
+        keyVersion: number;
     }): Promise<UncompressedPubKeySEC1>;
     getPublicKey(): Promise<UncompressedPubKeySEC1>;
     getLatestKeyVersion(): Promise<number>;
@@ -824,10 +829,11 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
      * parameters, it will throw an error.
      */
     sign(args: SignArgs, options?: SignOptions): Promise<RSVSignature>;
-    pollForRequestId({ requestId, payload, path, fromBlock, options, }: {
+    pollForRequestId({ requestId, payload, path, keyVersion, fromBlock, options, }: {
         requestId: Hex;
         payload: number[];
         path: string;
+        keyVersion: number;
         fromBlock: bigint;
         options?: RetryOptions;
     }): Promise<RSVSignature | SignatureErrorData | undefined>;
@@ -930,16 +936,56 @@ declare namespace errors {
  * IDL can be found at `target/idl/chain_signatures_project.json`.
  */
 interface ChainSignaturesProject {
-    address: '4uvZW8K4g4jBg7dzPNbb9XDxJLFBK7V6iC76uofmYvEU';
+    address: 'H5tHfpYoEnarrrzcV7sWBcZhiKMvL2aRpUYvb1ydWkwS';
     metadata: {
-        name: 'chainSignaturesProject';
-        version: '0.1.0';
+        name: 'chainSignatures';
+        version: '0.4.0';
         spec: '0.1.0';
-        description: 'Created with Anchor';
+        description: 'Chain signatures program for cross-chain signing on Solana';
+        repository: 'https://github.com/sig-net/signet-solana-program';
     };
     instructions: [
+        {
+            name: 'getSignatureDeposit';
+            docs: [
+                '* @dev Function to get the current signature deposit amount.\n     * @return The current signature deposit amount.'
+            ];
+            discriminator: [45, 243, 86, 86, 58, 57, 172, 253];
+            accounts: [
+                {
+                    name: 'programState';
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [
+                                    112,
+                                    114,
+                                    111,
+                                    103,
+                                    114,
+                                    97,
+                                    109,
+                                    45,
+                                    115,
+                                    116,
+                                    97,
+                                    116,
+                                    101
+                                ];
+                            }
+                        ];
+                    };
+                }
+            ];
+            args: [];
+            returns: 'u64';
+        },
         {
             name: 'initialize';
+            docs: [
+                '* @dev Function to initialize the program state.\n     * @param signature_deposit The deposit required for signature requests.\n     * @param chain_id The CAIP-2 chain identifier.'
+            ];
             discriminator: [175, 175, 109, 31, 13, 152, 155, 237];
             accounts: [
                 {
@@ -982,16 +1028,55 @@ interface ChainSignaturesProject {
                 {
                     name: 'signatureDeposit';
                     type: 'u64';
+                },
+                {
+                    name: 'chainId';
+                    type: 'string';
                 }
             ];
         },
         {
             name: 'respond';
+            docs: [
+                '* @dev Function to respond to signature requests.\n     * @param request_ids The array of request IDs.\n     * @param signatures The array of signature responses.\n     * @notice When multiple entries reuse a request id, events emit in canonical signature order (PSBT-style).'
+            ];
             discriminator: [72, 65, 227, 97, 42, 255, 147, 12];
             accounts: [
                 {
                     name: 'responder';
                     signer: true;
+                },
+                {
+                    name: 'eventAuthority';
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [
+                                    95,
+                                    95,
+                                    101,
+                                    118,
+                                    101,
+                                    110,
+                                    116,
+                                    95,
+                                    97,
+                                    117,
+                                    116,
+                                    104,
+                                    111,
+                                    114,
+                                    105,
+                                    116,
+                                    121
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'program';
                 }
             ];
             args: [
@@ -1016,8 +1101,11 @@ interface ChainSignaturesProject {
             ];
         },
         {
-            name: 'respondError';
-            discriminator: [3, 170, 41, 132, 72, 184, 252, 69];
+            name: 'respondBidirectional';
+            docs: [
+                '* @dev Function to finalize bidirectional flow\n     * @param request_id The ID of the signature request to respond to\n     * @param serialized_output output of the previously executed transaction\n     * @param signature ECDSA signature of the serialized output and request_id (keccak256(request_id.concat(serialized_output)))'
+            ];
+            discriminator: [138, 0, 45, 246, 236, 211, 109, 81];
             accounts: [
                 {
                     name: 'responder';
@@ -1026,23 +1114,55 @@ interface ChainSignaturesProject {
             ];
             args: [
                 {
-                    name: 'requestIds';
+                    name: 'requestId';
                     type: {
-                        vec: {
-                            array: ['u8', 32];
-                        };
+                        array: ['u8', 32];
                     };
                 },
+                {
+                    name: 'serializedOutput';
+                    type: 'bytes';
+                },
+                {
+                    name: 'signature';
+                    type: {
+                        defined: {
+                            name: 'signature';
+                        };
+                    };
+                }
+            ];
+        },
+        {
+            name: 'respondError';
+            docs: [
+                '* @dev Function to emit signature generation errors.\n     * @param errors The array of signature generation errors.'
+            ];
+            discriminator: [3, 170, 41, 132, 72, 184, 252, 69];
+            accounts: [
+                {
+                    name: 'responder';
+                    signer: true;
+                }
+            ];
+            args: [
                 {
                     name: 'errors';
                     type: {
-                        vec: 'string';
+                        vec: {
+                            defined: {
+                                name: 'errorResponse';
+                            };
+                        };
                     };
                 }
             ];
         },
         {
             name: 'sign';
+            docs: [
+                '* @dev Function to request a signature.\n     * @param payload The payload to be signed.\n     * @param key_version The version of the key used for signing.\n     * @param path The derivation path for the user account.\n     * @param algo The algorithm used for signing.\n     * @param dest The response destination.\n     * @param params Additional parameters.'
+            ];
             discriminator: [5, 221, 155, 46, 237, 91, 28, 236];
             accounts: [
                 {
@@ -1085,6 +1205,38 @@ interface ChainSignaturesProject {
                 {
                     name: 'systemProgram';
                     address: '11111111111111111111111111111111';
+                },
+                {
+                    name: 'eventAuthority';
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [
+                                    95,
+                                    95,
+                                    101,
+                                    118,
+                                    101,
+                                    110,
+                                    116,
+                                    95,
+                                    97,
+                                    117,
+                                    116,
+                                    104,
+                                    111,
+                                    114,
+                                    105,
+                                    116,
+                                    121
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'program';
                 }
             ];
             args: [
@@ -1116,8 +1268,139 @@ interface ChainSignaturesProject {
                 }
             ];
         },
+        {
+            name: 'signBidirectional';
+            docs: [
+                '* @dev Function to initiate bidirectional flow\n     * @param serialized_transaction transaction to be signed\n     * @param caip2_id chain identifier\n     * @param key_version The version of the key used for signing.\n     * @param path The derivation path for the user account.\n     * @param algo The algorithm used for signing.\n     * @param dest The response destination.\n     * @param params Additional parameters.\n     * @param program_id Program ID to callback after execution (not yet enabled).\n     * @param output_deserialization_schema schema for transaction output deserialization\n     * @param respond_serialization_schema serialization schema for respond_bidirectional payload'
+            ];
+            discriminator: [21, 104, 182, 213, 189, 143, 219, 48];
+            accounts: [
+                {
+                    name: 'programState';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [
+                                    112,
+                                    114,
+                                    111,
+                                    103,
+                                    114,
+                                    97,
+                                    109,
+                                    45,
+                                    115,
+                                    116,
+                                    97,
+                                    116,
+                                    101
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'requester';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'feePayer';
+                    writable: true;
+                    signer: true;
+                    optional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                },
+                {
+                    name: 'instructions';
+                    optional: true;
+                },
+                {
+                    name: 'eventAuthority';
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [
+                                    95,
+                                    95,
+                                    101,
+                                    118,
+                                    101,
+                                    110,
+                                    116,
+                                    95,
+                                    97,
+                                    117,
+                                    116,
+                                    104,
+                                    111,
+                                    114,
+                                    105,
+                                    116,
+                                    121
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'program';
+                }
+            ];
+            args: [
+                {
+                    name: 'serializedTransaction';
+                    type: 'bytes';
+                },
+                {
+                    name: 'caip2Id';
+                    type: 'string';
+                },
+                {
+                    name: 'keyVersion';
+                    type: 'u32';
+                },
+                {
+                    name: 'path';
+                    type: 'string';
+                },
+                {
+                    name: 'algo';
+                    type: 'string';
+                },
+                {
+                    name: 'dest';
+                    type: 'string';
+                },
+                {
+                    name: 'params';
+                    type: 'string';
+                },
+                {
+                    name: 'programId';
+                    type: 'pubkey';
+                },
+                {
+                    name: 'outputDeserializationSchema';
+                    type: 'bytes';
+                },
+                {
+                    name: 'respondSerializationSchema';
+                    type: 'bytes';
+                }
+            ];
+        },
         {
             name: 'updateDeposit';
+            docs: [
+                '* @dev Function to set the signature deposit amount.\n     * @param new_deposit The new deposit amount.'
+            ];
             discriminator: [126, 116, 15, 164, 238, 179, 155, 59];
             accounts: [
                 {
@@ -1166,6 +1449,9 @@ interface ChainSignaturesProject {
         },
         {
             name: 'withdrawFunds';
+            docs: [
+                '* @dev Function to withdraw funds from the program.\n     * @param amount The amount to withdraw.'
+            ];
             discriminator: [241, 36, 29, 111, 208, 31, 104, 217];
             accounts: [
                 {
@@ -1233,6 +1519,14 @@ interface ChainSignaturesProject {
             name: 'fundsWithdrawnEvent';
             discriminator: [86, 232, 194, 4, 211, 69, 172, 202];
         },
+        {
+            name: 'respondBidirectionalEvent';
+            discriminator: [195, 195, 28, 1, 102, 100, 189, 234];
+        },
+        {
+            name: 'signBidirectionalEvent';
+            discriminator: [135, 205, 217, 152, 96, 187, 11, 124];
+        },
         {
             name: 'signatureErrorEvent';
             discriminator: [42, 28, 210, 105, 9, 196, 189, 51];
@@ -1271,6 +1565,16 @@ interface ChainSignaturesProject {
             code: 6004;
             name: 'invalidRecipient';
             msg: 'Invalid recipient address';
+        },
+        {
+            code: 6005;
+            name: 'invalidTransaction';
+            msg: 'Invalid transaction data';
+        },
+        {
+            code: 6006;
+            name: 'missingInstructionSysvar';
+            msg: 'Missing instruction sysvar';
         }
     ];
     types: [
@@ -1296,6 +1600,9 @@ interface ChainSignaturesProject {
         },
         {
             name: 'depositUpdatedEvent';
+            docs: [
+                '* @dev Emitted when the deposit amount is updated.\n * @param old_deposit The previous deposit amount.\n * @param new_deposit The new deposit amount.'
+            ];
             type: {
                 kind: 'struct';
                 fields: [
@@ -1310,8 +1617,29 @@ interface ChainSignaturesProject {
                 ];
             };
         },
+        {
+            name: 'errorResponse';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'requestId';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'errorMessage';
+                        type: 'string';
+                    }
+                ];
+            };
+        },
         {
             name: 'fundsWithdrawnEvent';
+            docs: [
+                '* @dev Emitted when a withdrawal is made.\n * @param amount The amount withdrawn.\n * @param recipient The address of the recipient.'
+            ];
             type: {
                 kind: 'struct';
                 fields: [
@@ -1338,6 +1666,102 @@ interface ChainSignaturesProject {
                     {
                         name: 'signatureDeposit';
                         type: 'u64';
+                    },
+                    {
+                        name: 'chainId';
+                        type: 'string';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'respondBidirectionalEvent';
+            docs: [
+                '* @dev Emitted when a read response is received.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param serialized_output The serialized output.\n * @param signature The signature.'
+            ];
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'requestId';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'responder';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'serializedOutput';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'signature';
+                        type: {
+                            defined: {
+                                name: 'signature';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'signBidirectionalEvent';
+            docs: [
+                '* @dev Emitted when a sign_bidirectional request is made.\n * @param sender The address of the sender.\n * @param serialized_transaction The serialized transaction to be signed.\n * @param caip2_id The SLIP-44 chain ID.\n * @param key_version The version of the key used for signing.\n * @param deposit The deposit amount.\n * @param path The derivation path for the user account.\n * @param algo The algorithm used for signing.\n * @param dest The response destination.\n * @param params Additional parameters.\n * @param program_id Program ID to callback after execution (not yet enabled).\n * @param output_deserialization_schema Schema for transaction output deserialization.\n * @param respond_serialization_schema Serialization schema for respond_bidirectional payload.'
+            ];
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'sender';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'serializedTransaction';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'caip2Id';
+                        type: 'string';
+                    },
+                    {
+                        name: 'keyVersion';
+                        type: 'u32';
+                    },
+                    {
+                        name: 'deposit';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'path';
+                        type: 'string';
+                    },
+                    {
+                        name: 'algo';
+                        type: 'string';
+                    },
+                    {
+                        name: 'dest';
+                        type: 'string';
+                    },
+                    {
+                        name: 'params';
+                        type: 'string';
+                    },
+                    {
+                        name: 'programId';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'outputDeserializationSchema';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'respondSerializationSchema';
+                        type: 'bytes';
                     }
                 ];
             };
@@ -1370,6 +1794,9 @@ interface ChainSignaturesProject {
         },
         {
             name: 'signatureErrorEvent';
+            docs: [
+                '* @dev Emitted when a signature error is received.\n * @notice Any address can emit this event. Do not rely on it for business logic.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param error The error message.'
+            ];
             type: {
                 kind: 'struct';
                 fields: [
@@ -1392,6 +1819,9 @@ interface ChainSignaturesProject {
         },
         {
             name: 'signatureRequestedEvent';
+            docs: [
+                '* @dev Emitted when a signature is requested.\n * @param sender The address of the sender.\n * @param payload The payload to be signed.\n * @param key_version The version of the key used for signing.\n * @param deposit The deposit amount.\n * @param chain_id The CAIP-2 ID of the blockchain.\n * @param path The derivation path for the user account.\n * @param algo The algorithm used for signing.\n * @param dest The response destination.\n * @param params Additional parameters.\n * @param fee_payer Optional fee payer account.'
+            ];
             type: {
                 kind: 'struct';
                 fields: [
@@ -1415,7 +1845,7 @@ interface ChainSignaturesProject {
                     },
                     {
                         name: 'chainId';
-                        type: 'u64';
+                        type: 'string';
                     },
                     {
                         name: 'path';
@@ -1444,6 +1874,9 @@ interface ChainSignaturesProject {
         },
         {
             name: 'signatureRespondedEvent';
+            docs: [
+                '* @dev Emitted when a signature response is received.\n * @notice Any address can emit this event. Clients should always verify the validity of the signature.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param signature The signature response.'
+            ];
             type: {
                 kind: 'struct';
                 fields: [
@@ -1529,6 +1962,7 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
     getDerivedPublicKey(args: {
         path: string;
         predecessor: string;
+        keyVersion: number;
     }): Promise<UncompressedPubKeySEC1>;
     getPublicKey(): Promise<UncompressedPubKeySEC1>;
     getSignRequestInstruction(args: SignArgs, options?: Pick<SignOptions, 'sign'> & {
@@ -1582,14 +2016,45 @@ declare const utils: {
             version: string;
             spec: string;
             description: string;
+            repository: string;
         };
         instructions: ({
             name: string;
+            docs: string[];
             discriminator: number[];
             accounts: {
                 name: string;
-                signer: boolean;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
             }[];
+            args: never[];
+            returns: string;
+        } | {
+            name: string;
+            docs: string[];
+            discriminator: number[];
+            accounts: ({
+                name: string;
+                signer: boolean;
+                pda?: undefined;
+            } | {
+                name: string;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
+                signer?: undefined;
+            } | {
+                name: string;
+                signer?: undefined;
+                pda?: undefined;
+            })[];
             args: ({
                 name: string;
                 type: {
@@ -1609,8 +2074,10 @@ declare const utils: {
                     };
                 };
             })[];
+            returns?: undefined;
         } | {
             name: string;
+            docs: string[];
             discriminator: number[];
             accounts: {
                 name: string;
@@ -1619,18 +2086,25 @@ declare const utils: {
             args: ({
                 name: string;
                 type: {
-                    vec: {
-                        array: (string | number)[];
-                    };
+                    array: (string | number)[];
+                    defined?: undefined;
                 };
+            } | {
+                name: string;
+                type: string;
             } | {
                 name: string;
                 type: {
-                    vec: string;
+                    defined: {
+                        name: string;
+                    };
+                    array?: undefined;
                 };
             })[];
+            returns?: undefined;
         } | {
             name: string;
+            docs: string[];
             discriminator: number[];
             accounts: ({
                 name: string;
@@ -1665,6 +2139,25 @@ declare const utils: {
                 pda?: undefined;
                 signer?: undefined;
                 optional?: undefined;
+            } | {
+                name: string;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
+                writable?: undefined;
+                signer?: undefined;
+                optional?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                writable?: undefined;
+                pda?: undefined;
+                signer?: undefined;
+                optional?: undefined;
+                address?: undefined;
             })[];
             args: ({
                 name: string;
@@ -1675,8 +2168,79 @@ declare const utils: {
                 name: string;
                 type: string;
             })[];
+            returns?: undefined;
+        } | {
+            name: string;
+            docs: string[];
+            discriminator: number[];
+            accounts: ({
+                name: string;
+                writable: boolean;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
+                signer?: undefined;
+                optional?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                writable: boolean;
+                signer: boolean;
+                pda?: undefined;
+                optional?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                writable: boolean;
+                signer: boolean;
+                optional: boolean;
+                pda?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                address: string;
+                writable?: undefined;
+                pda?: undefined;
+                signer?: undefined;
+                optional?: undefined;
+            } | {
+                name: string;
+                optional: boolean;
+                writable?: undefined;
+                pda?: undefined;
+                signer?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
+                writable?: undefined;
+                signer?: undefined;
+                optional?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                writable?: undefined;
+                pda?: undefined;
+                signer?: undefined;
+                optional?: undefined;
+                address?: undefined;
+            })[];
+            args: {
+                name: string;
+                type: string;
+            }[];
+            returns?: undefined;
         } | {
             name: string;
+            docs: string[];
             discriminator: number[];
             accounts: ({
                 name: string;
@@ -1720,6 +2284,7 @@ declare const utils: {
                 name: string;
                 type: string;
             }[];
+            returns?: undefined;
         })[];
         accounts: {
             name: string;
@@ -1735,6 +2300,30 @@ declare const utils: {
             msg: string;
         }[];
         types: ({
+            name: string;
+            docs: string[];
+            type: {
+                kind: string;
+                fields: ({
+                    name: string;
+                    type: {
+                        array: (string | number)[];
+                        defined?: undefined;
+                    };
+                } | {
+                    name: string;
+                    type: string;
+                } | {
+                    name: string;
+                    type: {
+                        defined: {
+                            name: string;
+                        };
+                        array?: undefined;
+                    };
+                })[];
+            };
+        } | {
             name: string;
             type: {
                 kind: string;
@@ -1757,8 +2346,10 @@ declare const utils: {
                     type: string;
                 })[];
             };
+            docs?: undefined;
         } | {
             name: string;
+            docs: string[];
             type: {
                 kind: string;
                 fields: ({