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

package/src/chains/Bitcoin/Bitcoin.ts

@@ -0,0 +1,301 @@
+import * as bitcoin from 'bitcoinjs-lib'
+
+import { utils } from '@chains'
+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 { ChainSignatureContract } from '@chains/ChainSignatureContract'
+import type {
+  MPCPayloads,
+  RSVSignature,
+  KeyDerivationPath,
+} from '@chains/types'
+
+/**
+ * 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: ChainSignatureContract
+
+  /**
+   * 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
+  }) {
+    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 parseRSVSignature(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 (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: string): Promise<string> {
+    const balance = await this.btcRpcAdapter.getBalance(address)
+    return Bitcoin.toBTC(balance).toString()
+  }
+
+  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 = 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: BTCUnsignedTransaction,
+    storageKey: string
+  ): void {
+    window.localStorage.setItem(
+      storageKey,
+      JSON.stringify({
+        psbt: transaction.psbt.toHex(),
+        publicKey: transaction.publicKey,
+      })
+    )
+  }
+
+  getTransaction(
+    storageKey: string,
+    options?: {
+      remove?: boolean
+    }
+  ): BTCUnsignedTransaction | undefined {
+    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 as string),
+      publicKey: transactionJSON.publicKey,
+    }
+  }
+
+  async getMPCPayloadAndTransaction(
+    transactionRequest: BTCTransactionRequest
+  ): Promise<{
+    transaction: BTCUnsignedTransaction
+    mpcPayloads: MPCPayloads
+  }> {
+    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: MPCPayloads = []
+
+    const mockKeyPair = (index: number): bitcoin.Signer => ({
+      publicKey: publicKeyBuffer,
+      sign: (hash: Buffer): Buffer => {
+        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,
+  }: {
+    transaction: BTCUnsignedTransaction
+    mpcSignatures: RSVSignature[]
+  }): string {
+    const publicKeyBuffer = Buffer.from(publicKey, 'hex')
+
+    const keyPair = (index: number): bitcoin.Signer => ({
+      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: string): Promise<string> {
+    return await this.btcRpcAdapter.broadcastTransaction(txSerialized)
+  }
+}

package/src/chains/Bitcoin/types.ts

@@ -0,0 +1,45 @@
+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/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,96 @@
+import type {
+  KeyDerivationPath,
+  MPCPayloads,
+  RSVSignature,
+} from '@chains/types'
+
+export 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/src/chains/ChainSignatureContract.ts

@@ -0,0 +1,48 @@
+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
+}
+
+export 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>
+}