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

package/src/chains/Bitcoin/Bitcoin.ts

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

@@ -1,45 +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/utils.ts

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

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

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