signet.js 0.0.10-beta1 → 0.0.10-beta11

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.
      *
@@ -104,10 +107,12 @@ declare const ENVS: {
     readonly TESTNET_DEV: "TESTNET_DEV";
     readonly TESTNET: "TESTNET";
     readonly MAINNET: "MAINNET";
+    readonly SOLANA_STUB: "SOLANA_STUB";
 };
 declare const CHAINS: {
     readonly ETHEREUM: "ETHEREUM";
     readonly NEAR: "NEAR";
+    readonly SOLANA: "SOLANA";
 };
 /**
  * Root public keys for the Sig Network Smart Contracts across different environments.
@@ -124,6 +129,7 @@ declare const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey>;
 declare const KDF_CHAIN_IDS: {
     readonly ETHEREUM: "0x1";
     readonly NEAR: "0x18d";
+    readonly SOLANA: "0x800001f5";
 };
 /**
  * Contract addresses for different chains and environments.
@@ -134,7 +140,7 @@ declare const KDF_CHAIN_IDS: {
  *
  * @see ChainSignatureContract documentation for implementation details
  */
-declare const CONTRACT_ADDRESSES: Record<keyof typeof CHAINS, Record<keyof typeof ENVS, string>>;
+declare const CONTRACT_ADDRESSES: Record<keyof typeof CHAINS, Partial<Record<keyof typeof ENVS, string>>>;
 
 declare const constants_CHAINS: typeof CHAINS;
 declare const constants_CONTRACT_ADDRESSES: typeof CONTRACT_ADDRESSES;
@@ -182,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> {
@@ -382,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 {
@@ -528,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;
@@ -601,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;
@@ -734,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;
@@ -766,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: ({
@@ -893,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 {
@@ -929,21 +929,11 @@ interface SignOptions {
     };
     retry: RetryOptions;
 }
-interface SignatureErrorData {
+interface SignatureErrorData$1 {
     requestId: string;
     responder: string;
     error: string;
 }
-interface RequestIdArgs {
-    address: Address;
-    payload: Hex;
-    path: string;
-    keyVersion: number;
-    chainId: bigint;
-    algo: string;
-    dest: string;
-    params: string;
-}
 
 /**
  * Implementation of the ChainSignatureContract for EVM chains.
@@ -953,7 +943,7 @@ interface RequestIdArgs {
  * 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;
@@ -992,8 +982,8 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
         path: string;
         fromBlock: bigint;
         options?: RetryOptions;
-    }): Promise<RSVSignature | SignatureErrorData | undefined>;
-    getCallData(args: SignArgs, options?: SignOptions['sign']): Promise<{
+    }): Promise<RSVSignature | SignatureErrorData$1 | undefined>;
+    getSignRequestParams(args: SignArgs, options?: SignOptions['sign']): Promise<{
         target: Hex;
         data: Hex;
         value: bigint;
@@ -1001,34 +991,28 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
     /**
      * Generates the request ID for a signature request allowing to track the response.
      *
-     * @param request - The signature request object containing:
-     *   @param request.address - The contract/wallet address calling the signing contract
-     *   @param request.payload - The data payload to be signed as a hex string
-     *   @param request.path - The derivation path for the key
-     *   @param request.keyVersion - The version of the key to use
-     *   @param request.chainId - The chain ID as a bigint
-     *   @param request.algo - The signing algorithm to use
-     *   @param request.dest - The destination for the signature
-     *   @param request.params - Additional parameters for the signing process
+     * @param args - The signature request object containing:
+     *   @param args.payload - The data payload to be signed as a hex string
+     *   @param args.path - The derivation path for the key
+     *   @param args.keyVersion - The version of the key to use
+     * @param options - The signature request object containing:
+     *   @param options.algo - The signing algorithm to use
+     *   @param options.dest - The destination for the signature
+     *   @param options.params - Additional parameters for the signing process
      * @returns A hex string representing the unique request ID
      *
      * @example
      * ```typescript
      * const requestId = ChainSignatureContract.getRequestId({
-     *   address: walletClient.account.address,
      *   payload: payload: `0x${Buffer.from(args.payload).toString('hex')}`,,
      *   path: '',
-     *   keyVersion: 0,
-     *   chainId: 1n,
-     *   algo: '',
-     *   dest: '',
-     *   params: ''
+     *   keyVersion: 0
      * });
      * console.log(requestId); // 0x...
      * ```
      */
-    getRequestId(request: RequestIdArgs): Hex;
-    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData | undefined>;
+    getRequestId(args: SignArgs, options?: SignOptions['sign']): Hex;
+    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
@@ -1041,8 +1025,325 @@ 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>;
+    /**
+     * Listens for signature or error events matching the given requestId.
+     * Sets up listeners for both event types and returns a promise that resolves when
+     * either a valid signature or an error is received.
+     */
+    listenForSignatureEvents({ 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'] & {
+        requesterAddress?: string;
+    }): 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;
 };
 
@@ -1055,7 +1356,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 };