signet.js 0.0.12-beta.16 → 0.0.12-beta.18

package/types/index.d.cts

@@ -930,16 +930,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 +1022,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 +1095,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 +1108,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 +1199,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 +1262,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 +1443,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 +1513,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 +1559,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 +1594,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 +1611,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 +1660,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 +1788,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 +1813,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 +1839,7 @@ interface ChainSignaturesProject {
                     },
                     {
                         name: 'chainId';
-                        type: 'u64';
+                        type: 'string';
                     },
                     {
                         name: 'path';
@@ -1444,6 +1868,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: [
@@ -1582,14 +2009,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 +2067,10 @@ declare const utils: {
                     };
                 };
             })[];
+            returns?: undefined;
         } | {
             name: string;
+            docs: string[];
             discriminator: number[];
             accounts: {
                 name: string;
@@ -1619,18 +2079,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 +2132,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 +2161,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 +2277,7 @@ declare const utils: {
                 name: string;
                 type: string;
             }[];
+            returns?: undefined;
         })[];
         accounts: {
             name: string;
@@ -1735,6 +2293,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 +2339,10 @@ declare const utils: {
                     type: string;
                 })[];
             };
+            docs?: undefined;
         } | {
             name: string;
+            docs: string[];
             type: {
                 kind: string;
                 fields: ({