signet.js 0.0.1-beta.7 → 0.0.1-beta.8

package/chains/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.d.ts

@@ -0,0 +1,10 @@
+import { BTCTransaction, BTCInput, BTCOutput } from '../types';
+export declare abstract class BTCRpcAdapter {
+    abstract selectUTXOs(from: string, targets: BTCOutput[]): Promise<{
+        inputs: BTCInput[];
+        outputs: BTCOutput[];
+    }>;
+    abstract broadcastTransaction(transactionHex: string): Promise<string>;
+    abstract getBalance(address: string): Promise<number>;
+    abstract getTransaction(txid: string): Promise<BTCTransaction>;
+}

package/chains/Bitcoin/BTCRpcAdapter/Mempool/Mempool.d.ts

@@ -0,0 +1,15 @@
+import { BTCRpcAdapter } from '../BTCRpcAdapter';
+import { BTCTransaction, BTCInput, BTCOutput } from '../../types';
+export declare class Mempool extends BTCRpcAdapter {
+    private readonly providerUrl;
+    constructor(providerUrl: string);
+    private fetchFeeRate;
+    private fetchUTXOs;
+    selectUTXOs(from: string, targets: BTCOutput[], confirmationTarget?: number): Promise<{
+        inputs: BTCInput[];
+        outputs: BTCOutput[];
+    }>;
+    broadcastTransaction(transactionHex: string): Promise<string>;
+    getBalance(address: string): Promise<number>;
+    getTransaction(txid: string): Promise<BTCTransaction>;
+}

package/chains/Bitcoin/BTCRpcAdapter/Mempool/index.d.ts

@@ -0,0 +1 @@
+export { Mempool } from './Mempool';

package/chains/Bitcoin/BTCRpcAdapter/Mempool/types.d.ts

@@ -0,0 +1,69 @@
+export interface BTCFeeRecommendation {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    economyFee: number;
+    minimumFee: number;
+}
+interface BTCAddressStats {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+}
+export interface BTCAddressInfo {
+    address: string;
+    chain_stats: BTCAddressStats;
+    mempool_stats: BTCAddressStats;
+}
+export interface Transaction {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: Array<{
+        txid: string;
+        vout: number;
+        prevout: {
+            scriptpubkey: string;
+            scriptpubkey_asm: string;
+            scriptpubkey_type: string;
+            scriptpubkey_address: string;
+            value: number;
+        };
+        scriptsig: string;
+        scriptsig_asm: string;
+        witness: string[];
+        is_coinbase: boolean;
+        sequence: number;
+    }>;
+    vout: Array<{
+        scriptpubkey: string;
+        scriptpubkey_asm: string;
+        scriptpubkey_type: string;
+        scriptpubkey_address: string;
+        value: number;
+    }>;
+    size: number;
+    weight: number;
+    sigops?: number;
+    fee: number;
+    status: {
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
+}
+export interface UTXO {
+    txid: string;
+    vout: number;
+    status: {
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+    };
+    value: number;
+}
+export {};

package/chains/Bitcoin/BTCRpcAdapter/index.d.ts

@@ -0,0 +1,5 @@
+import { Mempool } from './Mempool';
+export { BTCRpcAdapter } from './BTCRpcAdapter';
+export declare const BTCRpcAdapters: {
+    Mempool: typeof Mempool;
+};

package/chains/Bitcoin/Bitcoin.d.ts

@@ -0,0 +1,69 @@
+import { BTCRpcAdapter } from './BTCRpcAdapter';
+import { BTCNetworkIds, BTCTransactionRequest, BTCUnsignedTransaction } from './types';
+import { Chain } from '../Chain';
+import { ChainSignatureContract } from '../ChainSignatureContract';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+import * as bitcoin from 'bitcoinjs-lib';
+/**
+ * Implementation of the Chain interface for Bitcoin network.
+ * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
+ */
+export declare class Bitcoin extends Chain<BTCTransactionRequest, BTCUnsignedTransaction> {
+    private static readonly SATOSHIS_PER_BTC;
+    private readonly network;
+    private readonly btcRpcAdapter;
+    private readonly contract;
+    /**
+     * Creates a new Bitcoin chain instance
+     * @param params - Configuration parameters
+     * @param params.network - Network identifier (mainnet/testnet)
+     * @param params.contract - Instance of the chain signature contract for MPC operations
+     * @param params.btcRpcAdapter - Bitcoin RPC adapter for network interactions
+     */
+    constructor({ network, contract, btcRpcAdapter, }: {
+        network: BTCNetworkIds;
+        contract: ChainSignatureContract;
+        btcRpcAdapter: BTCRpcAdapter;
+    });
+    /**
+     * Converts satoshis to BTC
+     * @param satoshis - Amount in satoshis
+     * @returns Amount in BTC
+     */
+    static toBTC(satoshis: number): number;
+    /**
+     * Converts BTC to satoshis
+     * @param btc - Amount in BTC
+     * @returns Amount in satoshis (rounded)
+     */
+    static toSatoshi(btc: number): number;
+    private fetchTransaction;
+    private static parseRSVSignature;
+    /**
+     * Creates a Partially Signed Bitcoin Transaction (PSBT)
+     * @param params - Parameters for creating the PSBT
+     * @param params.transactionRequest - Transaction request containing inputs and outputs
+     * @returns Created PSBT instance
+     */
+    createPSBT({ transactionRequest, }: {
+        transactionRequest: BTCTransactionRequest;
+    }): Promise<bitcoin.Psbt>;
+    getBalance(address: string): Promise<string>;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    setTransaction(transaction: BTCUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): BTCUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: BTCTransactionRequest): Promise<{
+        transaction: BTCUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction: { psbt, publicKey }, mpcSignatures, }: {
+        transaction: BTCUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/chains/Bitcoin/types.d.ts

@@ -0,0 +1,42 @@
+import type * as bitcoin from 'bitcoinjs-lib';
+export interface BTCTransaction {
+    vout: Array<{
+        scriptpubkey: string;
+        value: number;
+    }>;
+}
+export interface BTCInput {
+    txid: string;
+    vout: number;
+    value: number;
+    scriptPubKey: Buffer;
+}
+export type BTCOutput = {
+    value: number;
+} & ({
+    address: string;
+    script?: never;
+} | {
+    address?: never;
+    script: Buffer;
+});
+export type BTCTransactionRequest = {
+    publicKey: string;
+} & ({
+    inputs: BTCInput[];
+    outputs: BTCOutput[];
+    from?: never;
+    to?: never;
+    value?: never;
+} | {
+    inputs?: never;
+    outputs?: never;
+    from: string;
+    to: string;
+    value: string;
+});
+export interface BTCUnsignedTransaction {
+    psbt: bitcoin.Psbt;
+    publicKey: string;
+}
+export type BTCNetworkIds = 'mainnet' | 'testnet' | 'regtest';

package/chains/Bitcoin/utils.d.ts

@@ -0,0 +1,2 @@
+import * as bitcoin from 'bitcoinjs-lib';
+export declare function parseBTCNetwork(network: string): bitcoin.networks.Network;

package/chains/Chain.d.ts

@@ -0,0 +1,74 @@
+import { KeyDerivationPath, MPCPayloads, RSVSignature } from './types';
+export declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
+    /**
+     * Gets the native token balance for a given address
+     *
+     * @param address - The address to check
+     * @returns Promise resolving to the balance as a string, formatted according to the chain's decimal places (e.g. ETH, BTC, etc.)
+     */
+    abstract getBalance(address: string): Promise<string>;
+    /**
+     * Uses Sig Network Key Derivation Function to derive the address and public key. from a signer ID and string path.
+     *
+     * @param predecessor - The id/address of the account requesting signature
+     * @param path - The string path used to derive the key
+     * @returns Promise resolving to the derived address and public key
+     */
+    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    /**
+     * Stores an unsigned transaction in local storage for later use.
+     * Particularly useful for browser-based wallets that redirects the user to a different page.
+     *
+     * @param transaction - The unsigned transaction to store
+     * @param storageKey - Unique key to identify the stored transaction
+     */
+    abstract setTransaction(transaction: UnsignedTransaction, storageKey: string): void;
+    /**
+     * Retrieves a previously stored transaction from local storage.
+     *
+     * @param storageKey - The key used to store the transaction
+     * @param options - Additional options
+     * @param options.remove - If true, removes the transaction from storage after retrieval
+     * @returns The stored transaction or undefined if not found
+     */
+    abstract getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): UnsignedTransaction | undefined;
+    /**
+     * Prepares a transaction for Sig Network MPC signing by creating the necessary payloads.
+     * This method handles chain-specific transaction preparation including:
+     * - Fee calculation
+     * - Nonce/sequence management
+     * - UTXO selection (for UTXO-based chains)
+     * - Transaction encoding
+     *
+     * @param transactionRequest - The transaction request containing parameters like recipient, amount, etc.
+     * @returns Promise resolving to the unsigned transaction and MPC payloads for signing
+     */
+    abstract getMPCPayloadAndTransaction(transactionRequest: TransactionRequest): Promise<{
+        transaction: UnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    /**
+     * 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
+     * @returns The serialized signed transaction ready for broadcast
+     */
+    abstract addSignature(params: {
+        transaction: UnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    /**
+     * Broadcasts a signed transaction to the network.
+     *
+     * @param txSerialized - The serialized signed transaction
+     * @returns Promise resolving to the transaction hash/ID
+     */
+    abstract broadcastTx(txSerialized: string): Promise<string>;
+}

package/chains/ChainSignatureContract.d.ts

@@ -0,0 +1,41 @@
+import { default as BN } from 'bn.js';
+import { RSVSignature, UncompressedPubKeySEC1 } from './types';
+export interface SignArgs {
+    /** The payload to sign as an array of 32 bytes */
+    payload: number[];
+    /** The derivation path for key generation */
+    path: string;
+    /** Version of the key to use */
+    key_version: number;
+}
+export declare abstract class ChainSignatureContract {
+    /**
+     * Gets the current signature deposit required by the contract.
+     * This deposit amount helps manage network congestion.
+     *
+     * @returns Promise resolving to the required deposit amount as a BigNumber
+     */
+    abstract getCurrentSignatureDeposit(): Promise<BN>;
+    /**
+     * Signs a payload using Sig Network MPC.
+     *
+     * @param args - Arguments for the signing operation
+     * @param args.payload - The data to sign as an array of 32 bytes
+     * @param args.path - The string path to use derive the key
+     * @param args.key_version - Version of the key to use
+     * @returns Promise resolving to the RSV signature
+     */
+    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
+    /**
+     * Derives a child public key using a derivation path and predecessor.
+     *
+     * @param args - Arguments for key derivation
+     * @param args.path - The string path to use derive the key
+     * @param args.predecessor - The id/address of the account requesting signature
+     * @returns Promise resolving to the derived SEC1 uncompressed public key
+     */
+    abstract getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
+}

package/chains/Cosmos/Cosmos.d.ts

@@ -0,0 +1,51 @@
+import { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction } from './types';
+import { ChainSignatureContract } from '../ChainSignatureContract';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+import { Chain } from '../Chain';
+/**
+ * Implementation of the Chain interface for Cosmos-based networks.
+ * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+ */
+export declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTransaction> {
+    private readonly registry;
+    private readonly chainId;
+    private readonly contract;
+    private readonly endpoints?;
+    /**
+     * Creates a new Cosmos chain instance
+     * @param params - Configuration parameters
+     * @param params.chainId - Chain id for the Cosmos network
+     * @param params.contract - Instance of the chain signature contract for MPC operations
+     * @param params.endpoints - Optional RPC and REST endpoints
+     * @param params.endpoints.rpcUrl - Optional RPC endpoint URL
+     * @param params.endpoints.restUrl - Optional REST endpoint URL
+     */
+    constructor({ chainId, contract, endpoints, }: {
+        contract: ChainSignatureContract;
+        chainId: CosmosNetworkIds;
+        endpoints?: {
+            rpcUrl?: string;
+            restUrl?: string;
+        };
+    });
+    private parseRSVSignature;
+    private getChainInfo;
+    getBalance(address: string): Promise<string>;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    setTransaction(transaction: CosmosUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): CosmosUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: CosmosTransactionRequest): Promise<{
+        transaction: CosmosUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: CosmosUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/chains/Cosmos/types.d.ts

@@ -0,0 +1,30 @@
+import { EncodeObject } from '@cosmjs/proto-signing';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+export type CosmosNetworkIds = string;
+export type CosmosUnsignedTransaction = TxRaw;
+export interface CosmosTransactionRequest {
+    address: string;
+    publicKey: string;
+    messages: EncodeObject[];
+    memo?: string;
+    gas?: number;
+}
+export interface BalanceResponse {
+    balances: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    pagination: {
+        next_key: string | null;
+        total: string;
+    };
+}
+export interface ChainInfo {
+    prefix: string;
+    denom: string;
+    rpcUrl: string;
+    restUrl: string;
+    expectedChainId: string;
+    gasPrice: number;
+    decimals: number;
+}

package/chains/Cosmos/utils.d.ts

@@ -0,0 +1,2 @@
+import { ChainInfo } from './types';
+export declare const fetchChainInfo: (chainId: string) => Promise<ChainInfo>;

package/chains/EVM/EVM.d.ts

@@ -0,0 +1,42 @@
+import { Chain } from '../Chain';
+import { ChainSignatureContract } from '../ChainSignatureContract';
+import { EVMTransactionRequest, EVMUnsignedTransaction } from './types';
+import { MPCPayloads, RSVSignature, KeyDerivationPath } from '../types';
+/**
+ * Implementation of the Chain interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+export declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
+    private readonly provider;
+    private readonly contract;
+    /**
+     * Creates a new EVM chain instance
+     * @param params - Configuration parameters
+     * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
+     * @param params.contract - Instance of the chain signature contract for MPC operations
+     */
+    constructor({ rpcUrl, contract, }: {
+        rpcUrl: string;
+        contract: ChainSignatureContract;
+    });
+    private attachGasAndNonce;
+    private parseSignature;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    getBalance(address: string): Promise<string>;
+    setTransaction(transaction: EVMUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): EVMUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: EVMTransactionRequest): Promise<{
+        transaction: EVMUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: EVMUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/chains/EVM/types.d.ts

@@ -0,0 +1,5 @@
+import type * as ethers from 'ethers';
+export type EVMUnsignedTransaction = ethers.TransactionLike;
+export type EVMTransactionRequest = Omit<ethers.TransactionLike, 'from'> & {
+    from: string;
+};

package/chains/EVM/utils.d.ts

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+export declare function fetchEVMFeeProperties(providerUrl: string, transaction: ethers.TransactionLike): Promise<{
+    gasLimit: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFee: bigint;
+}>;

package/chains/index.d.ts

@@ -0,0 +1,12 @@
+export { Chain } from './Chain';
+export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract';
+export * from './types';
+export * as utils from './utils';
+export { EVM } from './EVM/EVM';
+export { fetchEVMFeeProperties } from './EVM/utils';
+export type { EVMTransactionRequest, EVMUnsignedTransaction } from './EVM/types';
+export { Bitcoin } from './Bitcoin/Bitcoin';
+export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter';
+export type { BTCTransactionRequest, BTCUnsignedTransaction, BTCTransaction, BTCOutput, BTCInput, BTCNetworkIds, } from './Bitcoin/types';
+export { Cosmos } from './Cosmos/Cosmos';
+export type { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction, } from './Cosmos/types';

package/chains/types.d.ts

@@ -0,0 +1,31 @@
+import { SignArgs } from './ChainSignatureContract';
+interface SuccessResponse {
+    transactionHash: string;
+    success: true;
+}
+interface FailureResponse {
+    success: false;
+    errorMessage: string;
+}
+export type Response = SuccessResponse | FailureResponse;
+export type MPCPayloads = Array<{
+    index: number;
+    payload: SignArgs['payload'];
+}>;
+export type UncompressedPubKeySEC1 = `04${string}`;
+export type KeyDerivationPath = string;
+export interface RSVSignature {
+    r: string;
+    s: string;
+    v: number;
+}
+export interface MPCSignature {
+    big_r: {
+        affine_point: string;
+    };
+    s: {
+        scalar: string;
+    };
+    recovery_id: number;
+}
+export {};

package/chains/utils.d.ts

@@ -0,0 +1,12 @@
+import { MPCSignature, RSVSignature, UncompressedPubKeySEC1 } from './types';
+export declare const toRSV: (signature: MPCSignature) => RSVSignature;
+/**
+ * Compresses an uncompressed public key to its compressed format following SEC1 standards.
+ * In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
+ * The prefix indicates whether the y-coordinate is even (02) or odd (03).
+ *
+ * @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
+ * @returns The compressed public key in hex format
+ * @throws Error if the uncompressed public key length is invalid
+ */
+export declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) => string;