signet.js 0.0.2-beta.5 → 0.0.2

package/types/index.d.ts

@@ -62,7 +62,7 @@ declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContra
     abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
 }
 
-type MPCPayloads = Array<SignArgs['payload']>;
+type HashToSign = SignArgs['payload'];
 type Base58String = string;
 type NajPublicKey = `secp256k1:${Base58String}`;
 type UncompressedPubKeySEC1 = `04${string}`;
@@ -73,7 +73,7 @@ interface RSVSignature {
     s: string;
     v: number;
 }
-interface OldMpcSignature {
+interface NearNearMpcSignature {
     big_r: {
         affine_point: string;
     };
@@ -82,12 +82,20 @@ interface OldMpcSignature {
     };
     recovery_id: number;
 }
-interface NewMpcSignature {
+interface SigNetNearMpcSignature {
     big_r: string;
     s: string;
     recovery_id: number;
 }
-type MPCSignature = OldMpcSignature | NewMpcSignature;
+interface SigNetEvmMpcSignature {
+    bigR: {
+        x: bigint;
+        y: bigint;
+    };
+    s: bigint;
+    recoveryId: number;
+}
+type MPCSignature = NearNearMpcSignature | SigNetNearMpcSignature | SigNetEvmMpcSignature;
 
 interface BTCTransaction$1 {
     vout: Array<{
@@ -236,10 +244,10 @@ interface CosmosRequest {
     fastAuthRelayerUrl?: string;
 }
 
-declare const mpcPayloadsToChainSigTransaction: ({ networkId, contractId, mpcPayloads, path, }: {
+declare const mpcPayloadsToChainSigTransaction: ({ networkId, contractId, hashesToSign, path, }: {
     networkId: NetworkId;
     contractId: ChainSignatureContractIds;
-    mpcPayloads: MPCPayloads;
+    hashesToSign: HashToSign[];
     path: KeyDerivationPath;
 }) => Promise<{
     receiverId: string;
@@ -271,22 +279,36 @@ declare namespace index$4 {
   export { index$4_keypair as keypair };
 }
 
-interface ChainSignatureContractArgs$1 {
+interface ChainSignatureContractArgs {
     networkId: NearNetworkIds;
     contractId: ChainSignatureContractIds;
     accountId?: string;
     keypair?: KeyPair;
 }
 /**
- * This contract will default to view methods only.
- * If you want to use the change methods, you need to provide an account and keypair.
+ * Implementation of the ChainSignatureContract for NEAR chains.
+ *
+ * This class provides an interface to interact with the ChainSignatures contract
+ * deployed on NEAR. It supports both view methods (which don't require authentication)
+ * and change methods (which require a valid NEAR account and keypair).
+ *
+ * @extends AbstractChainSignatureContract
  */
 declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
     private readonly networkId;
     private readonly contractId;
     private readonly accountId;
     private readonly keypair;
-    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs$1);
+    /**
+     * Creates a new instance of the ChainSignatureContract for NEAR chains.
+     *
+     * @param args - Configuration options for the contract
+     * @param args.networkId - The NEAR network ID (e.g. 'testnet', 'mainnet')
+     * @param args.contractId - The contract ID of the deployed ChainSignatures contract
+     * @param args.accountId - Optional NEAR account ID for signing transactions. Required for change methods.
+     * @param args.keypair - Optional NEAR KeyPair for signing transactions. Required for change methods.
+     */
+    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs);
     private getContract;
     getCurrentSignatureDeposit(): Promise<BN>;
     getDerivedPublicKey(args: {
@@ -302,12 +324,6 @@ declare namespace index$3 {
   export { ChainSignatureContract$1 as ChainSignatureContract, index$4 as signAndSend, index$3_transactionBuilder as transactionBuilder };
 }
 
-interface ChainSignatureContractArgs {
-    publicClient: PublicClient;
-    walletClient: WalletClient;
-    contractAddress: Hex;
-    rootPublicKey?: NajPublicKey;
-}
 interface SignOptions {
     sign: {
         algo?: string;
@@ -325,12 +341,34 @@ interface SignatureErrorData {
     error: string;
 }
 
+/**
+ * Implementation of the ChainSignatureContract for EVM chains.
+ *
+ * When signing data, the contract emits a SignatureRequested event with a requestId.
+ * This requestId is used to track the signature request and retrieve the signature
+ * 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 {
     private readonly publicClient;
     private readonly walletClient;
     private readonly contractAddress;
     private readonly rootPublicKey;
-    constructor(args: ChainSignatureContractArgs);
+    /**
+     * Creates a new instance of the ChainSignatureContract for EVM chains.
+     *
+     * @param args - Configuration options for the contract
+     * @param args.publicClient - A Viem PublicClient instance for reading from the blockchain
+     * @param args.walletClient - A Viem WalletClient instance for sending transactions
+     * @param args.contractAddress - The address of the deployed ChainSignatures contract (e.g. `0x857ED3A242B59cC24144814a0DF41C397a3811E6`)
+     * @param args.rootPublicKey - Optional root public key. If not provided, it will be derived from the contract address
+     */
+    constructor(args: {
+        publicClient: PublicClient;
+        walletClient: WalletClient;
+        contractAddress: Hex;
+        rootPublicKey?: NajPublicKey;
+    });
     getCurrentSignatureDeposit(): Promise<BN>;
     getDerivedPublicKey(args: {
         path: string;
@@ -344,10 +382,149 @@ declare class ChainSignatureContract extends ChainSignatureContract$2 {
     getSignatureFromEvents(requestId: `0x${string}`, receipt: TransactionReceipt): Promise<RSVSignature | undefined>;
 }
 
+declare const abi: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: ({
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        components: ({
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        } | {
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        })[];
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    })[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        components: ({
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        } | {
+            components: ({
+                components: {
+                    internalType: string;
+                    name: string;
+                    type: string;
+                }[];
+                internalType: string;
+                name: string;
+                type: string;
+            } | {
+                internalType: string;
+                name: string;
+                type: string;
+                components?: undefined;
+            })[];
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+
+declare class ChainSignatureError extends Error {
+    requestId: `0x${string}`;
+    receipt: TransactionReceipt;
+    constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SignatureNotFoundError extends ChainSignatureError {
+    constructor(requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SignatureContractError extends ChainSignatureError {
+    errorCode: string;
+    constructor(errorCode: string, requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SigningError 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 index$2_ChainSignatureContract = ChainSignatureContract;
 declare const index$2_ChainSignatureContract: typeof ChainSignatureContract;
+declare const index$2_abi: typeof abi;
+declare const index$2_errors: typeof errors;
 declare namespace index$2 {
-  export { index$2_ChainSignatureContract as ChainSignatureContract };
+  export { index$2_ChainSignatureContract as ChainSignatureContract, index$2_abi as abi, index$2_errors as errors };
 }
 
 declare namespace index$1 {
@@ -365,13 +542,19 @@ declare const toRSV: (signature: MPCSignature) => RSVSignature;
  * @throws Error if the uncompressed public key length is invalid
  */
 declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) => string;
+/**
+ * Converts a NAJ public key to an uncompressed SEC1 public key.
+ *
+ * @param najPublicKey - The NAJ public key to convert (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
+ * @returns The uncompressed SEC1 public key (e.g. 04 || x || y)
+ */
 declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => UncompressedPubKeySEC1;
 /**
  * Derives a child public key from a parent public key using the sig.network v1.0.0 epsilon derivation scheme.
- * The parent public keys are defined in @constants.ts as ROOT_PUBLIC_KEY_V1_SIG_NET_TESTNET and ROOT_PUBLIC_KEY_DEV_V1_SIG_NET_TESTNET.
+ * The parent public keys are defined in @constants.ts
  *
- * @param najPublicKey - The parent public key in NAJ format (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
- * @param predecessorId - The predecessor ID calling the signer contract
+ * @param najPublicKey - The parent public key in uncompressed SEC1 format (e.g. 04 || x || y)
+ * @param predecessorId - The predecessor ID is the address of the account calling the signer contract (e.g EOA or Contract Address)
  * @param path - Optional derivation path suffix (defaults to empty string)
  * @returns The derived child public key in uncompressed SEC1 format (04 || x || y)
  */
@@ -385,11 +568,6 @@ declare namespace cryptography {
   export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
 }
 
-declare const index_cryptography: typeof cryptography;
-declare namespace index {
-  export { index$1 as chains, index_cryptography as cryptography };
-}
-
 declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
     /**
      * Gets the native token balance and decimals for a given address
@@ -441,25 +619,25 @@ declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
      * @param transactionRequest - The transaction request containing parameters like recipient, amount, etc.
      * @returns Promise resolving to an object containing:
      *          - transaction: The unsigned transaction
-     *          - mpcPayloads: Array of payloads to be signed by MPC. The order of these payloads must match
+     *          - hashesToSign: Array of payloads to be signed by MPC. The order of these payloads must match
      *                         the order of signatures provided to attachTransactionSignature()
      */
     abstract prepareTransactionForSigning(transactionRequest: TransactionRequest): Promise<{
         transaction: UnsignedTransaction;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
     /**
      * Adds Sig Network MPC-generated signatures to an unsigned transaction.
      *
      * @param params - Parameters for adding signatures
      * @param params.transaction - The unsigned transaction to add signatures to
-     * @param params.mpcSignatures - Array of RSV signatures generated through MPC. Must be in the same order
+     * @param params.rsvSignatures - Array of RSV signatures generated through MPC. Must be in the same order
      *                              as the payloads returned by prepareTransactionForSigning()
      * @returns The serialized signed transaction ready for broadcast
      */
     abstract attachTransactionSignature(params: {
         transaction: UnsignedTransaction;
-        mpcSignatures: RSVSignature[];
+        rsvSignatures: RSVSignature[];
     }): string;
     /**
      * Broadcasts a signed transaction to the network.
@@ -488,7 +666,8 @@ declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
         contract: BaseChainSignatureContract;
     });
     private attachGasAndNonce;
-    private parseSignature;
+    private transformRSVSignature;
+    private assembleSignature;
     deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
         address: string;
         publicKey: string;
@@ -501,15 +680,13 @@ declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
     deserializeTransaction(serialized: `0x${string}`): EVMUnsignedTransaction;
     prepareTransactionForSigning(transactionRequest: EVMTransactionRequest): Promise<{
         transaction: EVMUnsignedTransaction;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
     prepareMessageForSigning(message: EVMMessage): Promise<{
-        message: EVMMessage;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
     prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
-        typedData: EVMTypedData;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
     /**
      * This implementation is a common step for Biconomy and Alchemy.
@@ -520,23 +697,21 @@ declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
      */
     prepareUserOpForSigning(userOp: UserOperationV7 | UserOperationV6, entryPointAddress?: Address, chainIdArgs?: number): Promise<{
         userOp: UserOperationV7 | UserOperationV6;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
+    attachTransactionSignature({ transaction, rsvSignatures, }: {
         transaction: EVMUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
+        rsvSignatures: RSVSignature[];
     }): `0x02${string}`;
-    attachMessageSignature({ mpcSignatures, }: {
-        message: string;
-        mpcSignatures: RSVSignature[];
+    assembleMessageSignature({ rsvSignatures, }: {
+        rsvSignatures: RSVSignature[];
     }): Hex;
-    attachTypedDataSignature({ mpcSignatures, }: {
-        typedData: EVMTypedData;
-        mpcSignatures: RSVSignature[];
+    assembleTypedDataSignature({ rsvSignatures, }: {
+        rsvSignatures: RSVSignature[];
     }): Hex;
-    attachUserOpSignature({ userOp, mpcSignatures, }: {
+    attachUserOpSignature({ userOp, rsvSignatures, }: {
         userOp: UserOperationV7 | UserOperationV6;
-        mpcSignatures: RSVSignature[];
+        rsvSignatures: RSVSignature[];
     }): UserOperationV7 | UserOperationV6;
     broadcastTx(txSerialized: `0x${string}`): Promise<Hash>;
 }
@@ -610,7 +785,7 @@ declare class Bitcoin extends Chain<BTCTransactionRequest, BTCUnsignedTransactio
      */
     static toSatoshi(btc: number): number;
     private fetchTransaction;
-    private static parseRSVSignature;
+    private static transformRSVSignature;
     /**
      * Creates a Partially Signed Bitcoin Transaction (PSBT)
      * @param params - Parameters for creating the PSBT
@@ -632,11 +807,11 @@ declare class Bitcoin extends Chain<BTCTransactionRequest, BTCUnsignedTransactio
     deserializeTransaction(serialized: string): BTCUnsignedTransaction;
     prepareTransactionForSigning(transactionRequest: BTCTransactionRequest): Promise<{
         transaction: BTCUnsignedTransaction;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
-    attachTransactionSignature({ transaction: { psbt, publicKey }, mpcSignatures, }: {
+    attachTransactionSignature({ transaction: { psbt, publicKey }, rsvSignatures, }: {
         transaction: BTCUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
+        rsvSignatures: RSVSignature[];
     }): string;
     broadcastTx(txSerialized: string): Promise<string>;
 }
@@ -667,7 +842,7 @@ declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTrans
             restUrl?: string;
         };
     });
-    private parseRSVSignature;
+    private transformRSVSignature;
     private getChainInfo;
     getBalance(address: string): Promise<{
         balance: bigint;
@@ -681,13 +856,64 @@ declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTrans
     deserializeTransaction(serialized: string): CosmosUnsignedTransaction;
     prepareTransactionForSigning(transactionRequest: CosmosTransactionRequest): Promise<{
         transaction: CosmosUnsignedTransaction;
-        mpcPayloads: MPCPayloads;
+        hashesToSign: HashToSign[];
     }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
+    attachTransactionSignature({ transaction, rsvSignatures, }: {
         transaction: CosmosUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
+        rsvSignatures: RSVSignature[];
     }): string;
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-export { type BTCInput, type BTCNetworkIds, type BTCOutput, BTCRpcAdapter, BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type BTCTransactionRequest, type BTCUnsignedTransaction, Bitcoin, Chain, ChainSignatureContract$2 as ChainSignatureContract, type CompressedPubKeySEC1, Cosmos, type CosmosNetworkIds, type CosmosTransactionRequest, type CosmosUnsignedTransaction, EVM, type EVMTransactionRequest, type EVMUnsignedTransaction, type KeyDerivationPath, type MPCPayloads, type MPCSignature, type NajPublicKey, type RSVSignature, type SignArgs, type UncompressedPubKeySEC1, fetchEVMFeeProperties, index as utils };
+declare const ENVS: {
+    readonly TESTNET_DEV: "TESTNET_DEV";
+    readonly TESTNET: "TESTNET";
+    readonly MAINNET: "MAINNET";
+};
+declare const CHAINS: {
+    readonly ETHEREUM: "ETHEREUM";
+    readonly NEAR: "NEAR";
+};
+/**
+ * Root public keys for the Sig Network Smart Contracts across different environments.
+ *
+ * These keys should never change.
+ */
+declare const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey>;
+/**
+ * Chain IDs used in the key derivation function (KDF) for deriving child public keys to
+ * distinguish between different chains.
+ *
+ * @see {@link deriveChildPublicKey} in cryptography.ts for usage details
+ */
+declare const KDF_CHAIN_IDS: {
+    readonly ETHEREUM: "0x1";
+    readonly NEAR: "0x18d";
+};
+/**
+ * Contract addresses for different chains and environments.
+ *
+ * - Testnet Dev: Used for internal development, very unstable
+ * - Testnet: Used for external development, stable
+ * - Mainnet: Production contract address
+ *
+ * @see ChainSignatureContract documentation for implementation details
+ */
+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;
+declare const constants_ENVS: typeof ENVS;
+declare const constants_KDF_CHAIN_IDS: typeof KDF_CHAIN_IDS;
+declare const constants_ROOT_PUBLIC_KEYS: typeof ROOT_PUBLIC_KEYS;
+declare namespace constants {
+  export { constants_CHAINS as CHAINS, constants_CONTRACT_ADDRESSES as CONTRACT_ADDRESSES, constants_ENVS as ENVS, constants_KDF_CHAIN_IDS as KDF_CHAIN_IDS, constants_ROOT_PUBLIC_KEYS as ROOT_PUBLIC_KEYS };
+}
+
+declare const index_constants: typeof constants;
+declare const index_cryptography: typeof cryptography;
+declare namespace index {
+  export { index$1 as chains, index_constants as constants, index_cryptography as cryptography };
+}
+
+export { type BTCInput, type BTCNetworkIds, type BTCOutput, BTCRpcAdapter, BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type BTCTransactionRequest, type BTCUnsignedTransaction, Bitcoin, Chain, ChainSignatureContract$2 as ChainSignatureContract, type CompressedPubKeySEC1, Cosmos, type CosmosNetworkIds, type CosmosTransactionRequest, type CosmosUnsignedTransaction, EVM, type EVMMessage, type EVMTransactionRequest, type EVMTypedData, type EVMUnsignedTransaction, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type SignArgs, type UncompressedPubKeySEC1, fetchEVMFeeProperties, index as utils };