signet.js 0.0.1-beta.1 → 0.0.1-beta.11

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

@@ -1,69 +0,0 @@
-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/src/chains/Bitcoin/BTCRpcAdapter/Mempool/types.js

@@ -1 +0,0 @@
-export {};

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

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

package/src/chains/Bitcoin/BTCRpcAdapter/index.js

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

package/src/chains/Bitcoin/Bitcoin.d.ts

@@ -1,66 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-import type { MPCPayloads, RSVSignature, KeyDerivationPath, ChainSignatureContract, BTCRpcAdapter, BTCNetworkIds, BTCTransactionRequest, BTCUnsignedTransaction } from '@chains';
-import { Chain } from '@chains';
-/**
- * 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/src/chains/Bitcoin/Bitcoin.js

@@ -1,197 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-import { Chain, utils } from '@chains';
-import { parseBTCNetwork } from '@chains/Bitcoin/utils';
-/**
- * Implementation of the Chain interface for Bitcoin network.
- * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
- */
-export class Bitcoin extends Chain {
-    /**
-     * 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, }) {
-        super();
-        this.network = network;
-        this.btcRpcAdapter = btcRpcAdapter;
-        this.contract = contract;
-    }
-    /**
-     * Converts satoshis to BTC
-     * @param satoshis - Amount in satoshis
-     * @returns Amount in BTC
-     */
-    static toBTC(satoshis) {
-        return satoshis / Bitcoin.SATOSHIS_PER_BTC;
-    }
-    /**
-     * Converts BTC to satoshis
-     * @param btc - Amount in BTC
-     * @returns Amount in satoshis (rounded)
-     */
-    static toSatoshi(btc) {
-        return Math.round(btc * Bitcoin.SATOSHIS_PER_BTC);
-    }
-    async fetchTransaction(transactionId) {
-        const data = await this.btcRpcAdapter.getTransaction(transactionId);
-        const tx = new bitcoin.Transaction();
-        data.vout.forEach((vout) => {
-            const scriptPubKey = Buffer.from(vout.scriptpubkey, 'hex');
-            tx.addOutput(scriptPubKey, Number(vout.value));
-        });
-        return tx;
-    }
-    static parseRSVSignature(signature) {
-        const r = signature.r.padStart(64, '0');
-        const s = signature.s.padStart(64, '0');
-        const rawSignature = Buffer.from(r + s, 'hex');
-        if (rawSignature.length !== 64) {
-            throw new Error('Invalid signature length.');
-        }
-        return rawSignature;
-    }
-    /**
-     * 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
-     */
-    async createPSBT({ transactionRequest, }) {
-        const { inputs, outputs } = transactionRequest.inputs && transactionRequest.outputs
-            ? transactionRequest
-            : await this.btcRpcAdapter.selectUTXOs(transactionRequest.from, [
-                {
-                    address: transactionRequest.to,
-                    value: parseFloat(transactionRequest.value),
-                },
-            ]);
-        const psbt = new bitcoin.Psbt({ network: parseBTCNetwork(this.network) });
-        await Promise.all(inputs.map(async (input) => {
-            if (!input.scriptPubKey) {
-                const transaction = await this.fetchTransaction(input.txid);
-                const prevOut = transaction.outs[input.vout];
-                input.scriptPubKey = prevOut.script;
-            }
-            // Prepare the input as P2WPKH
-            psbt.addInput({
-                hash: input.txid,
-                index: input.vout,
-                witnessUtxo: {
-                    script: input.scriptPubKey,
-                    value: input.value,
-                },
-            });
-        }));
-        outputs.forEach((out) => {
-            if (out.address) {
-                psbt.addOutput({
-                    address: out.address,
-                    value: out.value,
-                });
-            }
-            else if (out.script) {
-                psbt.addOutput({
-                    script: out.script,
-                    value: out.value,
-                });
-            }
-        });
-        return psbt;
-    }
-    async getBalance(address) {
-        const balance = await this.btcRpcAdapter.getBalance(address);
-        return Bitcoin.toBTC(balance).toString();
-    }
-    async deriveAddressAndPublicKey(predecessor, path) {
-        const uncompressedPubKey = await this.contract.getDerivedPublicKey({
-            path,
-            predecessor,
-        });
-        if (!uncompressedPubKey) {
-            throw new Error('Failed to get derived public key');
-        }
-        const derivedKey = utils.compressPubKey(uncompressedPubKey);
-        const publicKeyBuffer = Buffer.from(derivedKey, 'hex');
-        const network = parseBTCNetwork(this.network);
-        const payment = bitcoin.payments.p2wpkh({
-            pubkey: publicKeyBuffer,
-            network,
-        });
-        const { address } = payment;
-        if (!address) {
-            throw new Error('Failed to generate Bitcoin address');
-        }
-        return { address, publicKey: derivedKey };
-    }
-    setTransaction(transaction, storageKey) {
-        window.localStorage.setItem(storageKey, JSON.stringify({
-            psbt: transaction.psbt.toHex(),
-            publicKey: transaction.publicKey,
-        }));
-    }
-    getTransaction(storageKey, options) {
-        const txSerialized = window.localStorage.getItem(storageKey);
-        if (!txSerialized)
-            return undefined;
-        if (options?.remove) {
-            window.localStorage.removeItem(storageKey);
-        }
-        const transactionJSON = JSON.parse(txSerialized);
-        return {
-            psbt: bitcoin.Psbt.fromHex(transactionJSON.psbt),
-            publicKey: transactionJSON.publicKey,
-        };
-    }
-    async getMPCPayloadAndTransaction(transactionRequest) {
-        const publicKeyBuffer = Buffer.from(transactionRequest.publicKey, 'hex');
-        const psbt = await this.createPSBT({
-            transactionRequest,
-        });
-        // We can't double sign a PSBT, therefore we serialize the payload before to return it
-        const psbtHex = psbt.toHex();
-        const mpcPayloads = [];
-        const mockKeyPair = (index) => ({
-            publicKey: publicKeyBuffer,
-            sign: (hash) => {
-                mpcPayloads.push({
-                    index,
-                    payload: Array.from(hash),
-                });
-                // Return dummy signature to satisfy the interface
-                return Buffer.alloc(64);
-            },
-        });
-        for (let index = 0; index < psbt.inputCount; index++) {
-            psbt.signInput(index, mockKeyPair(index));
-        }
-        return {
-            transaction: {
-                psbt: bitcoin.Psbt.fromHex(psbtHex),
-                publicKey: transactionRequest.publicKey,
-            },
-            mpcPayloads: mpcPayloads.sort((a, b) => a.index - b.index),
-        };
-    }
-    addSignature({ transaction: { psbt, publicKey }, mpcSignatures, }) {
-        const publicKeyBuffer = Buffer.from(publicKey, 'hex');
-        const keyPair = (index) => ({
-            publicKey: publicKeyBuffer,
-            sign: () => {
-                const mpcSignature = mpcSignatures[index];
-                return Bitcoin.parseRSVSignature(mpcSignature);
-            },
-        });
-        for (let index = 0; index < psbt.inputCount; index++) {
-            psbt.signInput(index, keyPair(index));
-        }
-        psbt.finalizeAllInputs();
-        return psbt.extractTransaction().toHex();
-    }
-    async broadcastTx(txSerialized) {
-        return await this.btcRpcAdapter.broadcastTransaction(txSerialized);
-    }
-}
-Bitcoin.SATOSHIS_PER_BTC = 100000000;

package/src/chains/Bitcoin/types.d.ts

@@ -1,42 +0,0 @@
-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/src/chains/Bitcoin/types.js

@@ -1 +0,0 @@
-export {};

package/src/chains/Bitcoin/utils.d.ts

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

package/src/chains/Bitcoin/utils.js

@@ -1,13 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib';
-export function parseBTCNetwork(network) {
-    switch (network.toLowerCase()) {
-        case 'mainnet':
-            return bitcoin.networks.bitcoin;
-        case 'testnet':
-            return bitcoin.networks.testnet;
-        case 'regtest':
-            return bitcoin.networks.regtest;
-        default:
-            throw new Error(`Unknown Bitcoin network: ${network}`);
-    }
-}

package/src/chains/Chain.d.ts

@@ -1,89 +0,0 @@
-import type { KeyDerivationPath, MPCPayloads, RSVSignature } from '@chains';
-/**
- * Core interface for blockchain implementations.
- * Provides a standardized way to interact with different blockchain networks through a common set of methods.
- *
- * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
- * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
- */
-export declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
-    /**
-     * Gets the native token balance for a given address
-     *
-     * @param address - The blockchain 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.)
-     * @throws Error if the balance fetch fails or the address is invalid
-     */
-    abstract getBalance(address: string): Promise<string>;
-    /**
-     * Derives an address and public key from a signer ID and derivation path.
-     * Uses MPC (Multi-Party Computation) to derive the key pair securely.
-     *
-     * @param predecessor - The signer ID used to call the sign function on ChainSignatureContract
-     * @param path - The derivation path that uniquely identifies this key pair
-     * @returns Promise resolving to the derived address and its corresponding public key
-     * @throws Error if key derivation fails or the signer ID is invalid
-     */
-    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
-        address: string;
-        publicKey: string;
-    }>;
-    /**
-     * Stores an unsigned transaction in local storage for later use.
-     * This method persists transaction data between page reloads and browser sessions.
-     * Particularly useful for browser-based wallets that need to maintain transaction state.
-     *
-     * @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 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
-     * @throws Error if transaction preparation fails
-     */
-    abstract getMPCPayloadAndTransaction(transactionRequest: TransactionRequest): Promise<{
-        transaction: UnsignedTransaction;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * Adds MPC-generated signatures to an unsigned transaction.
-     * The signatures are applied according to the chain's specific signing scheme.
-     *
-     * @param params - Parameters for adding signatures
-     * @param params.transaction - The unsigned transaction to sign
-     * @param params.mpcSignatures - Array of RSV signatures generated through MPC
-     * @returns The serialized signed transaction ready for broadcast
-     * @throws Error if signature application fails
-     */
-    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
-     * @throws Error if broadcast fails or transaction is rejected
-     */
-    abstract broadcastTx(txSerialized: string): Promise<string>;
-}

package/src/chains/Chain.js

@@ -1,9 +0,0 @@
-/**
- * Core interface for blockchain implementations.
- * Provides a standardized way to interact with different blockchain networks through a common set of methods.
- *
- * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
- * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
- */
-export class Chain {
-}

package/src/chains/ChainSignatureContract.d.ts

@@ -1,62 +0,0 @@
-import type BN from 'bn.js';
-import type { RSVSignature, UncompressedPubKeySEC1 } from '@chains';
-/**
- * Arguments for the sign method
- */
-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;
-}
-/**
- * Abstract class defining the interface for chain signature contracts.
- * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
- * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
- */
-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
-     * @throws Error if the deposit check fails
-     */
-    abstract getCurrentSignatureDeposit(): Promise<BN>;
-    /**
-     * Gets the public key associated with this contract.
-     * This is the root public key from which child keys can be derived.
-     *
-     * @returns Promise resolving to the uncompressed public key
-     * @throws Error if public key retrieval fails
-     */
-    abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    /**
-     * Signs a payload using MPC.
-     * This is the core signing operation that coordinates with the MPC infrastructure.
-     *
-     * @param args - Arguments for the signing operation
-     * @param args.payload - The data to sign
-     * @param args.path - Derivation path for the signing key
-     * @param args.key_version - Version of the key to use
-     * @returns Promise resolving to the RSV signature
-     * @throws Error if signing fails or is rejected
-     */
-    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
-    /**
-     * Derives a child public key using a derivation path and predecessor.
-     * This method implements hierarchical deterministic key derivation.
-     *
-     * @param args - Arguments for key derivation
-     * @param args.path - The derivation path to use
-     * @param args.predecessor - The predecessor key (usually a NEAR account) that controls this derived key
-     * @returns Promise resolving to the derived uncompressed public key
-     * @throws Error if key derivation fails
-     */
-    abstract getDerivedPublicKey(args: {
-        path: string;
-        predecessor: string;
-    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
-}

package/src/chains/ChainSignatureContract.js

@@ -1,7 +0,0 @@
-/**
- * Abstract class defining the interface for chain signature contracts.
- * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
- * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
- */
-export class ChainSignatureContract {
-}

package/src/chains/Cosmos/Cosmos.d.ts

@@ -1,49 +0,0 @@
-import type { MPCPayloads, RSVSignature, KeyDerivationPath, CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction, ChainSignatureContract } from '@chains';
-import { Chain } from '@chains';
-/**
- * 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>;
-}