signet.js 0.0.10-beta9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signet.js",
-  "version": "0.0.10-beta9",
+  "version": "0.0.10",
   "description": "A TypeScript library for handling multi-chain transactions and signatures using Signet MPC",
   "type": "module",
   "exports": {
@@ -82,7 +82,6 @@
     "vocs": "1.0.0-alpha.62"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "^0.31.0",
     "@cosmjs/amino": "^0.32.4",
     "@cosmjs/crypto": "^0.32.4",
     "@cosmjs/encoding": "^0.32.4",
@@ -96,7 +95,6 @@
     "@near-js/types": "^0.3.1",
     "@near-wallet-selector/core": "^8.9.5",
     "@scure/base": "^1.2.4",
-    "@solana/web3.js": "^1.98.0",
     "bech32": "^2.0.0",
     "bitcoinjs-lib": "^6.1.5",
     "bn.js": "^5.2.1",

package/types/index.d.cts

@@ -8,9 +8,6 @@ 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 */
@@ -49,7 +46,7 @@ declare abstract class BaseChainSignatureContract {
 /**
  * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
  */
-declare abstract class ChainSignatureContract$3 extends BaseChainSignatureContract {
+declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContract {
     /**
      * Signs a payload using Sig Network MPC.
      *
@@ -107,12 +104,10 @@ 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.
@@ -129,7 +124,6 @@ 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.
@@ -140,7 +134,7 @@ declare const KDF_CHAIN_IDS: {
  *
  * @see ChainSignatureContract documentation for implementation details
  */
-declare const CONTRACT_ADDRESSES: Record<keyof typeof CHAINS, Partial<Record<keyof typeof ENVS, string>>>;
+declare const CONTRACT_ADDRESSES: Record<keyof typeof CHAINS, Record<keyof typeof ENVS, string>>;
 
 declare const constants_CHAINS: typeof CHAINS;
 declare const constants_CONTRACT_ADDRESSES: typeof CONTRACT_ADDRESSES;
@@ -188,9 +182,9 @@ declare namespace cryptography {
   export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
 }
 
-declare const index$8_cryptography: typeof cryptography;
-declare namespace index$8 {
-  export { index$8_cryptography as cryptography };
+declare const index$7_cryptography: typeof cryptography;
+declare namespace index$7 {
+  export { index$7_cryptography as cryptography };
 }
 
 declare abstract class ChainAdapter<TransactionRequest, UnsignedTransaction> {
@@ -388,15 +382,15 @@ interface EVMFeeProperties {
 }
 declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
 
-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 };
+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 };
 }
 
 interface BTCTransaction$1 {
@@ -534,18 +528,18 @@ declare class Bitcoin extends ChainAdapter<BTCTransactionRequest, BTCUnsignedTra
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-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 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 CosmosNetworkIds = string;
@@ -607,19 +601,19 @@ declare class Cosmos extends ChainAdapter<CosmosTransactionRequest, CosmosUnsign
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-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$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$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 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 ChainSignatureContractIds = string;
@@ -740,7 +734,7 @@ interface ChainSignatureContractArgs {
  *
  * @extends AbstractChainSignatureContract
  */
-declare class ChainSignatureContract$2 extends ChainSignatureContract$3 {
+declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
     private readonly networkId;
     private readonly contractId;
     private readonly accountId;
@@ -772,13 +766,13 @@ declare class ChainSignatureContract$2 extends ChainSignatureContract$3 {
     private requireAccount;
 }
 
-declare const utils$2: {
+declare const utils$1: {
     transaction: typeof transaction;
     signAndSend: typeof signAndSend;
 };
 
-declare namespace index$3 {
-  export { ChainSignatureContract$2 as ChainSignatureContract, utils$2 as utils };
+declare namespace index$2 {
+  export { ChainSignatureContract$1 as ChainSignatureContract, utils$1 as utils };
 }
 
 declare const abi: ({
@@ -899,41 +893,56 @@ declare class ChainSignatureError extends Error {
     receipt: TransactionReceipt;
     constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SignatureNotFoundError$1 extends ChainSignatureError {
+declare class SignatureNotFoundError extends ChainSignatureError {
     constructor(requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SignatureContractError$1 extends ChainSignatureError {
+declare class SignatureContractError extends ChainSignatureError {
     errorCode: string;
     constructor(errorCode: string, requestId: `0x${string}`, receipt: TransactionReceipt);
 }
-declare class SigningError$1 extends ChainSignatureError {
+declare class SigningError extends ChainSignatureError {
     originalError?: Error;
     constructor(requestId: `0x${string}`, receipt: TransactionReceipt, originalError?: Error);
 }
 
-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 };
+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 };
 }
 
-interface RetryOptions {
-    delay?: number;
-    retryCount?: number;
-}
 interface SignOptions {
     sign: {
         algo?: string;
         dest?: string;
         params?: string;
     };
-    retry: RetryOptions;
+    retry: {
+        delay?: number;
+        retryCount?: number;
+    };
 }
-interface SignatureErrorData$1 {
+interface SignatureErrorData {
     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.
@@ -943,7 +952,7 @@ interface SignatureErrorData$1 {
  * once it's available. The sign method handles this process automatically by polling
  * for the signature using the requestId.
  */
-declare class ChainSignatureContract$1 extends ChainSignatureContract$3 {
+declare class ChainSignatureContract extends ChainSignatureContract$2 {
     private readonly publicClient;
     private readonly walletClient;
     private readonly contractAddress;
@@ -970,49 +979,54 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract$3 {
     }): Promise<UncompressedPubKeySEC1>;
     getPublicKey(): Promise<UncompressedPubKeySEC1>;
     getLatestKeyVersion(): Promise<number>;
+    /**
+     * Sends a sign request transaction and return the transaction hash.
+     *
+     * @param args - The signature arguments
+     * @param options - The signing options
+     * @returns The transaction hash
+     */
+    createSignatureRequest(args: SignArgs, options?: Pick<SignOptions, 'sign'>): Promise<{
+        txHash: Hex;
+        requestId: Hex;
+    }>;
     /**
      * Sends a transaction to the contract 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, options?: SignOptions): Promise<RSVSignature>;
-    pollForRequestId({ requestId, payload, path, fromBlock, options, }: {
-        requestId: Hex;
-        payload: number[];
-        path: string;
-        fromBlock: bigint;
-        options?: RetryOptions;
-    }): Promise<RSVSignature | SignatureErrorData$1 | undefined>;
-    getSignRequestParams(args: SignArgs, options?: SignOptions['sign']): Promise<{
-        target: Hex;
-        data: Hex;
-        value: bigint;
-    }>;
     /**
      * Generates the request ID for a signature request allowing to track the response.
      *
-     * @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
+     * @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
      * @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
+     *   keyVersion: 0,
+     *   chainId: 1n,
+     *   algo: '',
+     *   dest: '',
+     *   params: ''
      * });
      * console.log(requestId); // 0x...
      * ```
      */
-    getRequestId(args: SignArgs, options?: SignOptions['sign']): Hex;
-    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData$1 | undefined>;
+    getRequestId(request: RequestIdArgs): Hex;
+    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData | undefined>;
     /**
      * Searches for SignatureResponded events that match the given requestId.
      * It works in conjunction with the getRequestId method which generates the unique
@@ -1025,323 +1039,8 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract$3 {
     getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
 }
 
-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']): 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;
-                    };
-                })[];
-            };
-        })[];
-    };
+    ChainSignaturesContractABI: typeof ChainSignaturesContractABI;
     errors: typeof errors;
 };
 
@@ -1354,7 +1053,7 @@ declare namespace index$1 {
 
 type index_SignArgs = SignArgs;
 declare namespace index {
-  export { ChainSignatureContract$3 as ChainSignatureContract, type index_SignArgs as SignArgs, index$2 as evm, index$3 as near, index$1 as solana };
+  export { ChainSignatureContract$2 as ChainSignatureContract, type index_SignArgs as SignArgs, index$1 as evm, index$2 as near };
 }
 
-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 };
+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 };