signet.js 0.0.10-beta6 → 0.0.10-beta8

package/types/index.d.ts

@@ -8,6 +8,9 @@ import { Action as Action$1 } from '@near-js/transactions';
 import { TxExecutionStatus } from '@near-js/types';
 import { NetworkId, Action, FinalExecutionOutcome } from '@near-wallet-selector/core';
 import { KeyPair as KeyPair$1 } from 'near-api-js';
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey } from '@solana/web3.js';
+import { AnchorProvider, Wallet } from '@coral-xyz/anchor';
 
 interface SignArgs {
     /** The payload to sign as an array of 32 bytes */
@@ -46,7 +49,7 @@ declare abstract class BaseChainSignatureContract {
 /**
  * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
  */
-declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContract {
+declare abstract class ChainSignatureContract$3 extends BaseChainSignatureContract {
     /**
      * Signs a payload using Sig Network MPC.
      *
@@ -185,9 +188,9 @@ declare namespace cryptography {
   export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
 }
 
-declare const index$7_cryptography: typeof cryptography;
-declare namespace index$7 {
-  export { index$7_cryptography as cryptography };
+declare const index$8_cryptography: typeof cryptography;
+declare namespace index$8 {
+  export { index$8_cryptography as cryptography };
 }
 
 declare abstract class ChainAdapter<TransactionRequest, UnsignedTransaction> {
@@ -385,15 +388,15 @@ interface EVMFeeProperties {
 }
 declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
 
-type index$6_EVM = EVM;
-declare const index$6_EVM: typeof EVM;
-type index$6_EVMMessage = EVMMessage;
-type index$6_EVMTransactionRequest = EVMTransactionRequest;
-type index$6_EVMTypedData = EVMTypedData;
-type index$6_EVMUnsignedTransaction = EVMUnsignedTransaction;
-declare const index$6_fetchEVMFeeProperties: typeof fetchEVMFeeProperties;
-declare namespace index$6 {
-  export { index$6_EVM as EVM, type index$6_EVMMessage as EVMMessage, type index$6_EVMTransactionRequest as EVMTransactionRequest, type index$6_EVMTypedData as EVMTypedData, type index$6_EVMUnsignedTransaction as EVMUnsignedTransaction, index$6_fetchEVMFeeProperties as fetchEVMFeeProperties };
+type index$7_EVM = EVM;
+declare const index$7_EVM: typeof EVM;
+type index$7_EVMMessage = EVMMessage;
+type index$7_EVMTransactionRequest = EVMTransactionRequest;
+type index$7_EVMTypedData = EVMTypedData;
+type index$7_EVMUnsignedTransaction = EVMUnsignedTransaction;
+declare const index$7_fetchEVMFeeProperties: typeof fetchEVMFeeProperties;
+declare namespace index$7 {
+  export { index$7_EVM as EVM, type index$7_EVMMessage as EVMMessage, type index$7_EVMTransactionRequest as EVMTransactionRequest, type index$7_EVMTypedData as EVMTypedData, type index$7_EVMUnsignedTransaction as EVMUnsignedTransaction, index$7_fetchEVMFeeProperties as fetchEVMFeeProperties };
 }
 
 interface BTCTransaction$1 {
@@ -531,18 +534,18 @@ declare class Bitcoin extends ChainAdapter<BTCTransactionRequest, BTCUnsignedTra
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-type index$5_BTCInput = BTCInput;
-type index$5_BTCNetworkIds = BTCNetworkIds;
-type index$5_BTCOutput = BTCOutput;
-type index$5_BTCRpcAdapter = BTCRpcAdapter;
-declare const index$5_BTCRpcAdapter: typeof BTCRpcAdapter;
-declare const index$5_BTCRpcAdapters: typeof BTCRpcAdapters;
-type index$5_BTCTransactionRequest = BTCTransactionRequest;
-type index$5_BTCUnsignedTransaction = BTCUnsignedTransaction;
-type index$5_Bitcoin = Bitcoin;
-declare const index$5_Bitcoin: typeof Bitcoin;
-declare namespace index$5 {
-  export { type index$5_BTCInput as BTCInput, type index$5_BTCNetworkIds as BTCNetworkIds, type index$5_BTCOutput as BTCOutput, index$5_BTCRpcAdapter as BTCRpcAdapter, index$5_BTCRpcAdapters as BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type index$5_BTCTransactionRequest as BTCTransactionRequest, type index$5_BTCUnsignedTransaction as BTCUnsignedTransaction, index$5_Bitcoin as Bitcoin };
+type index$6_BTCInput = BTCInput;
+type index$6_BTCNetworkIds = BTCNetworkIds;
+type index$6_BTCOutput = BTCOutput;
+type index$6_BTCRpcAdapter = BTCRpcAdapter;
+declare const index$6_BTCRpcAdapter: typeof BTCRpcAdapter;
+declare const index$6_BTCRpcAdapters: typeof BTCRpcAdapters;
+type index$6_BTCTransactionRequest = BTCTransactionRequest;
+type index$6_BTCUnsignedTransaction = BTCUnsignedTransaction;
+type index$6_Bitcoin = Bitcoin;
+declare const index$6_Bitcoin: typeof Bitcoin;
+declare namespace index$6 {
+  export { type index$6_BTCInput as BTCInput, type index$6_BTCNetworkIds as BTCNetworkIds, type index$6_BTCOutput as BTCOutput, index$6_BTCRpcAdapter as BTCRpcAdapter, index$6_BTCRpcAdapters as BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type index$6_BTCTransactionRequest as BTCTransactionRequest, type index$6_BTCUnsignedTransaction as BTCUnsignedTransaction, index$6_Bitcoin as Bitcoin };
 }
 
 type CosmosNetworkIds = string;
@@ -604,19 +607,19 @@ declare class Cosmos extends ChainAdapter<CosmosTransactionRequest, CosmosUnsign
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-type index$4_Cosmos = Cosmos;
-declare const index$4_Cosmos: typeof Cosmos;
-type index$4_CosmosNetworkIds = CosmosNetworkIds;
-type index$4_CosmosTransactionRequest = CosmosTransactionRequest;
-type index$4_CosmosUnsignedTransaction = CosmosUnsignedTransaction;
-declare namespace index$4 {
-  export { index$4_Cosmos as Cosmos, type index$4_CosmosNetworkIds as CosmosNetworkIds, type index$4_CosmosTransactionRequest as CosmosTransactionRequest, type index$4_CosmosUnsignedTransaction as CosmosUnsignedTransaction };
+type index$5_Cosmos = Cosmos;
+declare const index$5_Cosmos: typeof Cosmos;
+type index$5_CosmosNetworkIds = CosmosNetworkIds;
+type index$5_CosmosTransactionRequest = CosmosTransactionRequest;
+type index$5_CosmosUnsignedTransaction = CosmosUnsignedTransaction;
+declare namespace index$5 {
+  export { index$5_Cosmos as Cosmos, type index$5_CosmosNetworkIds as CosmosNetworkIds, type index$5_CosmosTransactionRequest as CosmosTransactionRequest, type index$5_CosmosUnsignedTransaction as CosmosUnsignedTransaction };
 }
 
-type index$3_ChainAdapter<TransactionRequest, UnsignedTransaction> = ChainAdapter<TransactionRequest, UnsignedTransaction>;
-declare const index$3_ChainAdapter: typeof ChainAdapter;
-declare namespace index$3 {
-  export { index$3_ChainAdapter as ChainAdapter, index$5 as btc, index$4 as cosmos, index$6 as evm };
+type index$4_ChainAdapter<TransactionRequest, UnsignedTransaction> = ChainAdapter<TransactionRequest, UnsignedTransaction>;
+declare const index$4_ChainAdapter: typeof ChainAdapter;
+declare namespace index$4 {
+  export { index$4_ChainAdapter as ChainAdapter, index$6 as btc, index$5 as cosmos, index$7 as evm };
 }
 
 type ChainSignatureContractIds = string;
@@ -737,7 +740,7 @@ interface ChainSignatureContractArgs {
  *
  * @extends AbstractChainSignatureContract
  */
-declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
+declare class ChainSignatureContract$2 extends ChainSignatureContract$3 {
     private readonly networkId;
     private readonly contractId;
     private readonly accountId;
@@ -769,13 +772,13 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
     private requireAccount;
 }
 
-declare const utils$1: {
+declare const utils$2: {
     transaction: typeof transaction;
     signAndSend: typeof signAndSend;
 };
 
-declare namespace index$2 {
-  export { ChainSignatureContract$1 as ChainSignatureContract, utils$1 as utils };
+declare namespace index$3 {
+  export { ChainSignatureContract$2 as ChainSignatureContract, utils$2 as utils };
 }
 
 declare const abi: ({
@@ -896,28 +899,22 @@ declare class ChainSignatureError extends Error {
     receipt: TransactionReceipt;
     constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SignatureNotFoundError extends ChainSignatureError {
+declare class SignatureNotFoundError$1 extends ChainSignatureError {
     constructor(requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SignatureContractError extends ChainSignatureError {
+declare class SignatureContractError$1 extends ChainSignatureError {
     errorCode: string;
     constructor(errorCode: string, requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SigningError extends ChainSignatureError {
+declare class SigningError$1 extends ChainSignatureError {
     originalError?: Error;
     constructor(requestId: `0x${string}`, receipt: TransactionReceipt, originalError?: Error);
 }
 
-type errors_ChainSignatureError = ChainSignatureError;
-declare const errors_ChainSignatureError: typeof ChainSignatureError;
-type errors_SignatureContractError = SignatureContractError;
-declare const errors_SignatureContractError: typeof SignatureContractError;
-type errors_SignatureNotFoundError = SignatureNotFoundError;
-declare const errors_SignatureNotFoundError: typeof SignatureNotFoundError;
-type errors_SigningError = SigningError;
-declare const errors_SigningError: typeof SigningError;
-declare namespace errors {
-  export { errors_ChainSignatureError as ChainSignatureError, errors_SignatureContractError as SignatureContractError, errors_SignatureNotFoundError as SignatureNotFoundError, errors_SigningError as SigningError };
+type errors$1_ChainSignatureError = ChainSignatureError;
+declare const errors$1_ChainSignatureError: typeof ChainSignatureError;
+declare namespace errors$1 {
+  export { errors$1_ChainSignatureError as ChainSignatureError, SignatureContractError$1 as SignatureContractError, SignatureNotFoundError$1 as SignatureNotFoundError, SigningError$1 as SigningError };
 }
 
 interface RetryOptions {
@@ -932,7 +929,7 @@ interface SignOptions {
     };
     retry: RetryOptions;
 }
-interface SignatureErrorData {
+interface SignatureErrorData$1 {
     requestId: string;
     responder: string;
     error: string;
@@ -946,7 +943,7 @@ interface SignatureErrorData {
  * once it's available. The sign method handles this process automatically by polling
  * for the signature using the requestId.
  */
-declare class ChainSignatureContract extends ChainSignatureContract$2 {
+declare class ChainSignatureContract$1 extends ChainSignatureContract$3 {
     private readonly publicClient;
     private readonly walletClient;
     private readonly contractAddress;
@@ -985,7 +982,7 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
         path: string;
         fromBlock: bigint;
         options?: RetryOptions;
-    }): Promise<RSVSignature | SignatureErrorData | undefined>;
+    }): Promise<RSVSignature | SignatureErrorData$1 | undefined>;
     getSignRequestParams(args: SignArgs, options?: SignOptions['sign']): Promise<{
         target: Hex;
         data: Hex;
@@ -1015,7 +1012,7 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
      * ```
      */
     getRequestId(args: SignArgs, options?: SignOptions['sign']): Hex;
-    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData | undefined>;
+    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData$1 | undefined>;
     /**
      * Searches for SignatureResponded events that match the given requestId.
      * It works in conjunction with the getRequestId method which generates the unique
@@ -1028,8 +1025,318 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
     getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
 }
 
-declare const utils: {
+declare const utils$1: {
     ChainSignaturesContractABI: typeof ChainSignaturesContractABI;
+    errors: typeof errors$1;
+};
+
+declare namespace index$2 {
+  export { ChainSignatureContract$1 as ChainSignatureContract, utils$1 as utils };
+}
+
+type SignatureErrorData = {
+    requestId: Uint8Array;
+    responder: PublicKey;
+    error: string;
+};
+declare class SignatureNotFoundError extends Error {
+    readonly requestId?: string;
+    readonly hash?: string;
+    constructor(requestId?: string, metadata?: {
+        hash?: string;
+    });
+}
+declare class SignatureContractError extends Error {
+    readonly requestId?: string;
+    readonly hash?: string;
+    readonly originalError?: any;
+    constructor(message: string, requestId?: string, metadata?: {
+        hash?: string;
+    });
+}
+declare class SigningError extends Error {
+    readonly requestId: string;
+    readonly hash?: string;
+    readonly originalError?: Error;
+    constructor(requestId: string, metadata?: {
+        hash?: string;
+    }, originalError?: Error);
+}
+declare class ResponseError extends Error {
+    constructor(message: string);
+}
+
+type errors_ResponseError = ResponseError;
+declare const errors_ResponseError: typeof ResponseError;
+type errors_SignatureContractError = SignatureContractError;
+declare const errors_SignatureContractError: typeof SignatureContractError;
+type errors_SignatureErrorData = SignatureErrorData;
+type errors_SignatureNotFoundError = SignatureNotFoundError;
+declare const errors_SignatureNotFoundError: typeof SignatureNotFoundError;
+type errors_SigningError = SigningError;
+declare const errors_SigningError: typeof SigningError;
+declare namespace errors {
+  export { errors_ResponseError as ResponseError, errors_SignatureContractError as SignatureContractError, type errors_SignatureErrorData as SignatureErrorData, errors_SignatureNotFoundError as SignatureNotFoundError, errors_SigningError as SigningError };
+}
+
+declare class ChainSignatureContract extends ChainSignatureContract$3 {
+    private readonly provider;
+    private readonly program;
+    private readonly programId;
+    private readonly rootPublicKey;
+    /**
+     * Creates a new instance of the ChainSignatureContract for Solana chains.
+     *
+     * @param args - Configuration options for the contract
+     * @param args.provider - An Anchor Provider for interacting with Solana
+     * @param args.programId - The program ID as a string or PublicKey
+     * @param args.rootPublicKey - Optional root public key. If not provided, it will be derived from the program ID
+     */
+    constructor(args: {
+        provider: AnchorProvider;
+        programId: string | PublicKey;
+        rootPublicKey?: NajPublicKey;
+    });
+    /**
+     * Gets the connection from the provider
+     */
+    get connection(): _solana_web3_js.Connection;
+    getCurrentSignatureDeposit(): Promise<BN>;
+    /**
+     * Get the Program State PDA
+     */
+    getProgramStatePDA(): Promise<PublicKey>;
+    getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    }): Promise<UncompressedPubKeySEC1>;
+    getPublicKey(): Promise<UncompressedPubKeySEC1>;
+    /**
+     * Sends a transaction to the program to request a signature, then
+     * polls for the signature result. If the signature is not found within the retry
+     * parameters, it will throw an error.
+     */
+    sign(args: SignArgs & {
+        feePayer?: Wallet;
+    }, options?: SignOptions): Promise<RSVSignature>;
+    pollForRequestId({ requestId, payload, path, options, }: {
+        requestId: string;
+        payload: number[];
+        path: string;
+        options?: RetryOptions;
+    }): Promise<RSVSignature | SignatureErrorData$1 | undefined>;
+    /**
+     * Generates the request ID for a signature request allowing to track the response.
+     */
+    getRequestId(args: SignArgs, options?: SignOptions['sign']): string;
+}
+
+declare const utils: {
+    ChainSignaturesContractIdl: {
+        address: string;
+        metadata: {
+            name: string;
+            version: string;
+            spec: string;
+            description: string;
+        };
+        instructions: ({
+            name: string;
+            discriminator: number[];
+            accounts: {
+                name: string;
+                signer: boolean;
+            }[];
+            args: ({
+                name: string;
+                type: {
+                    vec: {
+                        array: (string | number)[];
+                        defined?: undefined;
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    vec: {
+                        defined: {
+                            name: string;
+                        };
+                        array?: undefined;
+                    };
+                };
+            })[];
+        } | {
+            name: string;
+            discriminator: number[];
+            accounts: {
+                name: string;
+                signer: boolean;
+            }[];
+            args: ({
+                name: string;
+                type: {
+                    vec: {
+                        array: (string | number)[];
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    vec: string;
+                };
+            })[];
+        } | {
+            name: 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;
+            })[];
+            args: ({
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+            } | {
+                name: string;
+                type: string;
+            })[];
+        } | {
+            name: string;
+            discriminator: number[];
+            accounts: ({
+                name: string;
+                writable: boolean;
+                pda: {
+                    seeds: {
+                        kind: string;
+                        value: number[];
+                    }[];
+                };
+                signer?: undefined;
+                relations?: undefined;
+                docs?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                writable: boolean;
+                signer: boolean;
+                relations: string[];
+                pda?: undefined;
+                docs?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                docs: string[];
+                writable: boolean;
+                pda?: undefined;
+                signer?: undefined;
+                relations?: undefined;
+                address?: undefined;
+            } | {
+                name: string;
+                address: string;
+                writable?: undefined;
+                pda?: undefined;
+                signer?: undefined;
+                relations?: undefined;
+                docs?: undefined;
+            })[];
+            args: {
+                name: string;
+                type: string;
+            }[];
+        })[];
+        accounts: {
+            name: string;
+            discriminator: number[];
+        }[];
+        events: {
+            name: string;
+            discriminator: number[];
+        }[];
+        errors: {
+            code: number;
+            name: string;
+            msg: string;
+        }[];
+        types: ({
+            name: string;
+            type: {
+                kind: string;
+                fields: ({
+                    name: string;
+                    type: {
+                        defined: {
+                            name: string;
+                        };
+                        array?: undefined;
+                    };
+                } | {
+                    name: string;
+                    type: {
+                        array: (string | number)[];
+                        defined?: undefined;
+                    };
+                } | {
+                    name: string;
+                    type: string;
+                })[];
+            };
+        } | {
+            name: string;
+            type: {
+                kind: string;
+                fields: ({
+                    name: string;
+                    type: string;
+                } | {
+                    name: string;
+                    type: {
+                        array: (string | number)[];
+                        option?: undefined;
+                    };
+                } | {
+                    name: string;
+                    type: {
+                        option: string;
+                        array?: undefined;
+                    };
+                })[];
+            };
+        })[];
+    };
     errors: typeof errors;
 };
 
@@ -1042,7 +1349,7 @@ declare namespace index$1 {
 
 type index_SignArgs = SignArgs;
 declare namespace index {
-  export { ChainSignatureContract$2 as ChainSignatureContract, type index_SignArgs as SignArgs, index$1 as evm, index$2 as near };
+  export { ChainSignatureContract$3 as ChainSignatureContract, type index_SignArgs as SignArgs, index$2 as evm, index$3 as near, index$1 as solana };
 }
 
-export { type CompressedPubKeySEC1, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type UncompressedPubKeySEC1, index$3 as chainAdapters, constants, index as contracts, index$7 as utils };
+export { type CompressedPubKeySEC1, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type UncompressedPubKeySEC1, index$4 as chainAdapters, constants, index as contracts, index$8 as utils };