signet.js 0.0.1-beta.0

package/README.md

@@ -0,0 +1,75 @@
+# Signet.js
+
+A TypeScript library for handling multi-chain transactions and signatures using MPC (Multi-Party Computation).
+
+## Overview
+
+This library provides a unified interface for interacting with different blockchain networks through a common set of methods. It uses MPC for secure key management and transaction signing.
+
+## Features
+
+- **Multi-Chain Support**: Built-in support for EVM chains, Bitcoin, and Cosmos networks
+- **Unified Interface**: Common API across all supported chains
+- **MPC Integration**: Secure key management and transaction signing
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+- **Modular Design**: Easy to extend with new chain implementations
+- **Secure**: No private keys stored or transmitted
+
+## Installation
+
+```bash
+npm install signet.js
+# or
+yarn add signet.js
+# or
+pnpm add signet.js
+```
+
+## Quick Example
+
+```ts twoslash
+import { EVM, near } from 'signet.js'
+
+// Initialize MPC contract
+const contract = new near.contract.ChainSignaturesContract({
+  networkId: 'testnet',
+  contractId: 'mpc.testnet',
+})
+
+// Initialize chain
+const chain = new EVM({
+  rpcUrl: 'https://mainnet.infura.io/v3/YOUR-PROJECT-ID',
+  contract,
+})
+
+// Create and sign transaction
+const { transaction, mpcPayloads } = await chain.getMPCPayloadAndTransaction({
+  to: '0x1234...',
+  value: '1000000000000000000', // 1 ETH
+})
+
+const signature = await contract.sign({
+  payload: mpcPayloads[0].payload,
+  path: 'any_string',
+  key_version: 0,
+})
+
+const signedTx = chain.addSignature({
+  transaction,
+  mpcSignatures: [signature],
+})
+
+const txHash = await chain.broadcastTx(signedTx)
+```
+
+## Documentation
+
+For detailed documentation, including:
+
+- Getting started guide
+- Chain-specific implementations
+- MPC system overview
+- Implementation guides
+- API reference
+
+Visit our [documentation site](https://near.github.io/signet.js).

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "signet.js",
+  "version": "0.0.1-beta.0",
+  "description": "",
+  "type": "module",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "pre:deploy": "npm run build && cp package.json README.md dist/",
+    "publish-npm": "npm run pre:deploy && cd dist && npm publish",
+    "publish-npm:beta": "npm run pre:deploy && cd dist && npm publish --tag beta",
+    "test": "jest",
+    "docs:dev": "vocs dev",
+    "docs:build": "vocs build",
+    "docs:preview": "vocs preview"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/preset-env": "^7.25.3",
+    "@babel/preset-typescript": "^7.24.7",
+    "@types/bn.js": "^5.1.5",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "babel-jest": "^29.7.0",
+    "dotenv": "^16.4.5",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-standard-with-typescript": "^43.0.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.3",
+    "vocs": "1.0.0-alpha.62"
+  },
+  "dependencies": {
+    "@cosmjs/amino": "^0.32.4",
+    "@cosmjs/crypto": "^0.32.4",
+    "@cosmjs/encoding": "^0.32.4",
+    "@cosmjs/math": "^0.32.4",
+    "@cosmjs/proto-signing": "^0.32.4",
+    "@cosmjs/stargate": "^0.32.4",
+    "@near-js/accounts": "^1.3.0",
+    "@near-js/crypto": "^1.4.0",
+    "@near-js/keystores": "^0.2.0",
+    "@near-js/transactions": "^1.3.1",
+    "@near-wallet-selector/core": "^8.9.5",
+    "bech32": "^2.0.0",
+    "bitcoinjs-lib": "^6.1.5",
+    "bn.js": "^5.2.1",
+    "bs58": "^6.0.0",
+    "chain-registry": "^1.69.72",
+    "coinselect": "^3.1.13",
+    "cosmjs-types": "^0.9.0",
+    "ethers": "^6.11.1",
+    "near-api-js": "^3.0.4"
+  },
+  "packageManager": "pnpm@9.15.1+sha512.1acb565e6193efbebda772702950469150cf12bcc764262e7587e71d19dc98a423dff9536e57ea44c49bdf790ff694e83c27be5faa23d67e0c033b583be4bfcf"
+}

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

@@ -0,0 +1,10 @@
+import type { BTCTransaction, BTCInput, BTCOutput } from '@chains';
+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/src/chains/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.js

@@ -0,0 +1,2 @@
+export class BTCRpcAdapter {
+}

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

@@ -0,0 +1,15 @@
+import { BTCRpcAdapter } from '@chains';
+import type { BTCTransaction, BTCInput, BTCOutput } from '@chains';
+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/src/chains/Bitcoin/BTCRpcAdapter/Mempool/Mempool.js

@@ -0,0 +1,69 @@
+// There is no types for coinselect
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+import coinselect from 'coinselect';
+import { BTCRpcAdapter } from '@chains';
+export class Mempool extends BTCRpcAdapter {
+    constructor(providerUrl) {
+        super();
+        this.providerUrl = providerUrl;
+    }
+    async fetchFeeRate(confirmationTarget = 6) {
+        const response = await fetch(`${this.providerUrl}/v1/fees/recommended`);
+        const data = (await response.json());
+        if (confirmationTarget <= 1) {
+            return data.fastestFee;
+        }
+        else if (confirmationTarget <= 3) {
+            return data.halfHourFee;
+        }
+        else if (confirmationTarget <= 6) {
+            return data.hourFee;
+        }
+        else {
+            return data.economyFee;
+        }
+    }
+    async fetchUTXOs(address) {
+        try {
+            const response = await fetch(`${this.providerUrl}/address/${address}/utxo`);
+            return (await response.json());
+        }
+        catch (error) {
+            console.error('Failed to fetch UTXOs:', error);
+            return [];
+        }
+    }
+    async selectUTXOs(from, targets, confirmationTarget = 6) {
+        const utxos = await this.fetchUTXOs(from);
+        const feeRate = await this.fetchFeeRate(confirmationTarget);
+        // Add a small amount to the fee rate to ensure the transaction is confirmed
+        const ret = coinselect(utxos, targets, Math.ceil(feeRate + 1));
+        if (!ret.inputs || !ret.outputs) {
+            throw new Error('Invalid transaction: coinselect failed to find a suitable set of inputs and outputs. This could be due to insufficient funds, or no inputs being available that meet the criteria.');
+        }
+        return {
+            inputs: ret.inputs,
+            outputs: ret.outputs,
+        };
+    }
+    async broadcastTransaction(transactionHex) {
+        const response = await fetch(`${this.providerUrl}/tx`, {
+            method: 'POST',
+            body: transactionHex,
+        });
+        if (response.ok) {
+            return await response.text();
+        }
+        throw new Error(`Failed to broadcast transaction: ${await response.text()}`);
+    }
+    async getBalance(address) {
+        const response = await fetch(`${this.providerUrl}/address/${address}`);
+        const data = (await response.json());
+        return data.chain_stats.funded_txo_sum - data.chain_stats.spent_txo_sum;
+    }
+    async getTransaction(txid) {
+        const response = await fetch(`${this.providerUrl}/tx/${txid}`);
+        return (await response.json());
+    }
+}

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

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

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

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

package/src/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/src/chains/Bitcoin/BTCRpcAdapter/Mempool/types.js

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

package/src/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/src/chains/Bitcoin/BTCRpcAdapter/index.js

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

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -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/src/chains/Bitcoin/types.js

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

package/src/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/src/chains/Bitcoin/utils.js

@@ -0,0 +1,13 @@
+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}`);
+    }
+}