signet.js 0.0.2 → 0.0.3

package/src/chains/Bitcoin/Bitcoin.ts

@@ -0,0 +1,287 @@
+import * as bitcoin from 'bitcoinjs-lib'
+
+import { type BTCRpcAdapter } from '@chains/Bitcoin/BTCRpcAdapter'
+import type {
+  BTCInput,
+  BTCNetworkIds,
+  BTCOutput,
+  BTCTransactionRequest,
+  BTCUnsignedTransaction,
+} from '@chains/Bitcoin/types'
+import { parseBTCNetwork } from '@chains/Bitcoin/utils'
+import { Chain } from '@chains/Chain'
+import type { BaseChainSignatureContract } from '@chains/ChainSignatureContract'
+import type { HashToSign, RSVSignature, KeyDerivationPath } from '@chains/types'
+import { cryptography } from '@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<
+  BTCTransactionRequest,
+  BTCUnsignedTransaction
+> {
+  private static readonly SATOSHIS_PER_BTC = 100_000_000
+
+  private readonly network: BTCNetworkIds
+  private readonly btcRpcAdapter: BTCRpcAdapter
+  private readonly contract: BaseChainSignatureContract
+
+  /**
+   * 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: BaseChainSignatureContract
+    btcRpcAdapter: 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: number): number {
+    return satoshis / Bitcoin.SATOSHIS_PER_BTC
+  }
+
+  /**
+   * Converts BTC to satoshis
+   * @param btc - Amount in BTC
+   * @returns Amount in satoshis (rounded)
+   */
+  static toSatoshi(btc: number): number {
+    return Math.round(btc * Bitcoin.SATOSHIS_PER_BTC)
+  }
+
+  private async fetchTransaction(
+    transactionId: string
+  ): Promise<bitcoin.Transaction> {
+    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
+  }
+
+  private static transformRSVSignature(signature: RSVSignature): Buffer {
+    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,
+  }: {
+    transactionRequest: BTCTransactionRequest
+  }): Promise<bitcoin.Psbt> {
+    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: BTCInput) => {
+        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: BTCOutput) => {
+      if ('address' in out) {
+        psbt.addOutput({
+          address: out.address,
+          value: out.value,
+        })
+      } else if ('script' in out) {
+        psbt.addOutput({
+          script: out.script,
+          value: out.value,
+        })
+      } else if (transactionRequest.from !== undefined) {
+        // Include change address from coinselect
+        psbt.addOutput({
+          value: Number(out.value),
+          address: transactionRequest.from,
+        })
+      }
+    })
+
+    return psbt
+  }
+
+  async getBalance(
+    address: string
+  ): Promise<{ balance: bigint; decimals: number }> {
+    const balance = BigInt(await this.btcRpcAdapter.getBalance(address))
+    return {
+      balance,
+      decimals: 8,
+    }
+  }
+
+  async deriveAddressAndPublicKey(
+    predecessor: string,
+    path: KeyDerivationPath
+  ): Promise<{ address: string; publicKey: string }> {
+    const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+      path,
+      predecessor,
+    })
+
+    if (!uncompressedPubKey) {
+      throw new Error('Failed to get derived public key')
+    }
+
+    const derivedKey = cryptography.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 }
+  }
+
+  serializeTransaction(transaction: BTCUnsignedTransaction): string {
+    return JSON.stringify({
+      psbt: transaction.psbt.toHex(),
+      publicKey: transaction.publicKey,
+    })
+  }
+
+  deserializeTransaction(serialized: string): BTCUnsignedTransaction {
+    const transactionJSON = JSON.parse(serialized)
+    return {
+      psbt: bitcoin.Psbt.fromHex(transactionJSON.psbt as string),
+      publicKey: transactionJSON.publicKey,
+    }
+  }
+
+  async prepareTransactionForSigning(
+    transactionRequest: BTCTransactionRequest
+  ): Promise<{
+    transaction: BTCUnsignedTransaction
+    hashesToSign: HashToSign[]
+  }> {
+    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 hashesToSign: HashToSign[] = []
+
+    const mockKeyPair = (index: number): bitcoin.Signer => ({
+      publicKey: publicKeyBuffer,
+      sign: (hash: Buffer): Buffer => {
+        hashesToSign[index] = 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,
+      },
+      hashesToSign,
+    }
+  }
+
+  attachTransactionSignature({
+    transaction: { psbt, publicKey },
+    rsvSignatures,
+  }: {
+    transaction: BTCUnsignedTransaction
+    rsvSignatures: RSVSignature[]
+  }): string {
+    const publicKeyBuffer = Buffer.from(publicKey, 'hex')
+
+    const keyPair = (index: number): bitcoin.Signer => ({
+      publicKey: publicKeyBuffer,
+      sign: () => {
+        const mpcSignature = rsvSignatures[index]
+        return Bitcoin.transformRSVSignature(mpcSignature)
+      },
+    })
+
+    for (let index = 0; index < psbt.inputCount; index++) {
+      psbt.signInput(index, keyPair(index))
+    }
+
+    psbt.finalizeAllInputs()
+    return psbt.extractTransaction().toHex()
+  }
+
+  async broadcastTx(txSerialized: string): Promise<string> {
+    return await this.btcRpcAdapter.broadcastTransaction(txSerialized)
+  }
+}

package/src/chains/Bitcoin/types.ts

@@ -0,0 +1,48 @@
+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; value: number }
+  | { script: Buffer; value: number }
+
+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/utils.ts

@@ -0,0 +1,14 @@
+import * as bitcoin from 'bitcoinjs-lib'
+
+export function parseBTCNetwork(network: string): bitcoin.networks.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.ts

@@ -0,0 +1,92 @@
+import type { KeyDerivationPath, HashToSign, RSVSignature } from '@chains/types'
+
+export abstract class Chain<TransactionRequest, UnsignedTransaction> {
+  /**
+   * Gets the native token balance and decimals for a given address
+   *
+   * @param address - The address to check
+   * @returns Promise resolving to an object containing:
+   *          - balance: The balance as a bigint, in the chain's base units
+   *          - decimals: The number of decimals used to format the balance
+   */
+  abstract getBalance(address: string): Promise<{
+    balance: bigint
+    decimals: number
+  }>
+
+  /**
+   * 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
+  }>
+
+  /**
+   * Serializes an unsigned transaction to a string format.
+   * This is useful for storing or transmitting the transaction.
+   *
+   * @param transaction - The unsigned transaction to serialize
+   * @returns The serialized transaction string
+   */
+  abstract serializeTransaction(transaction: UnsignedTransaction): string
+
+  /**
+   * Deserializes a transaction string back into an unsigned transaction object.
+   * This reverses the serialization done by serializeTransaction().
+   *
+   * @param serialized - The serialized transaction string
+   * @returns The deserialized unsigned transaction
+   */
+  abstract deserializeTransaction(serialized: string): UnsignedTransaction
+
+  /**
+   * 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 an object containing:
+   *          - transaction: The unsigned transaction
+   *          - 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
+    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.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
+    rsvSignatures: 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/src/chains/ChainSignatureContract.ts

@@ -0,0 +1,65 @@
+import type BN from 'bn.js'
+
+import type { RSVSignature, UncompressedPubKeySEC1 } from '@chains/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
+}
+
+/**
+ * Base contract interface required for compatibility with Chain instances like EVM and Bitcoin.
+ *
+ * See {@link EVM} and {@link Bitcoin} for example implementations.
+ */
+export abstract class BaseChainSignatureContract {
+  /**
+   * 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>
+
+  /**
+   * 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>
+}
+
+/**
+ * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
+ */
+export abstract class ChainSignatureContract extends BaseChainSignatureContract {
+  /**
+   * 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>
+
+  /**
+   * Gets the public key associated with this contract instance.
+   *
+   * @returns Promise resolving to the SEC1 uncompressed public key
+   */
+  abstract getPublicKey(): Promise<UncompressedPubKeySEC1>
+}