signet.js 0.0.7 → 0.0.9-retry

package/src/chain-adapters/Bitcoin/Bitcoin.ts

@@ -1,287 +0,0 @@
-import * as bitcoin from 'bitcoinjs-lib'
-
-import { type BTCRpcAdapter } from '@chain-adapters/Bitcoin/BTCRpcAdapter'
-import type {
-  BTCInput,
-  BTCNetworkIds,
-  BTCOutput,
-  BTCTransactionRequest,
-  BTCUnsignedTransaction,
-} from '@chain-adapters/Bitcoin/types'
-import { parseBTCNetwork } from '@chain-adapters/Bitcoin/utils'
-import { ChainAdapter } from '@chain-adapters/ChainAdapter'
-import type { BaseChainSignatureContract } from '@contracts/ChainSignatureContract'
-import type { HashToSign, RSVSignature, KeyDerivationPath } from '@types'
-import { cryptography } from '@utils'
-
-/**
- * Implementation of the ChainAdapter interface for Bitcoin network.
- * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
- */
-export class Bitcoin extends ChainAdapter<
-  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,
-    }
-  }
-
-  finalizeTransactionSigning({
-    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/chain-adapters/Bitcoin/index.ts

@@ -1,13 +0,0 @@
-// Bitcoin
-export { Bitcoin } from './Bitcoin'
-
-export { BTCRpcAdapters, BTCRpcAdapter } from './BTCRpcAdapter'
-
-export type {
-  BTCTransactionRequest,
-  BTCUnsignedTransaction,
-  BTCTransaction,
-  BTCOutput,
-  BTCInput,
-  BTCNetworkIds,
-} from './types'

package/src/chain-adapters/Bitcoin/types.ts

@@ -1,48 +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; 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/chain-adapters/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/chain-adapters/ChainAdapter.ts

@@ -1,92 +0,0 @@
-import type { KeyDerivationPath, HashToSign, RSVSignature } from '@types'
-
-export abstract class ChainAdapter<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 finalizeTransactionSigning()
-   */
-  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 finalizeTransactionSigning(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/chain-adapters/Cosmos/Cosmos.ts

@@ -1,258 +0,0 @@
-import { encodeSecp256k1Pubkey } from '@cosmjs/amino'
-import { ripemd160, sha256 } from '@cosmjs/crypto'
-import { toBase64, fromBase64, fromHex } from '@cosmjs/encoding'
-import {
-  Registry,
-  makeSignBytes,
-  encodePubkey,
-  makeAuthInfoBytes,
-  makeSignDoc,
-  type TxBodyEncodeObject,
-} from '@cosmjs/proto-signing'
-import { GasPrice, StargateClient, calculateFee } from '@cosmjs/stargate'
-import { bech32 } from 'bech32'
-import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing'
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx'
-
-import { ChainAdapter } from '@chain-adapters/ChainAdapter'
-import type {
-  CosmosNetworkIds,
-  CosmosTransactionRequest,
-  CosmosUnsignedTransaction,
-  ChainInfo,
-  BalanceResponse,
-} from '@chain-adapters/Cosmos/types'
-import { fetchChainInfo } from '@chain-adapters/Cosmos/utils'
-import type { BaseChainSignatureContract } from '@contracts/ChainSignatureContract'
-import type { HashToSign, RSVSignature, KeyDerivationPath } from '@types'
-import { cryptography } from '@utils'
-
-/**
- * Implementation of the ChainAdapter interface for Cosmos-based networks.
- * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
- */
-export class Cosmos extends ChainAdapter<
-  CosmosTransactionRequest,
-  CosmosUnsignedTransaction
-> {
-  private readonly registry: Registry
-  private readonly chainId: CosmosNetworkIds
-  private readonly contract: BaseChainSignatureContract
-  private readonly endpoints?: {
-    rpcUrl?: string
-    restUrl?: string
-  }
-
-  /**
-   * 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: BaseChainSignatureContract
-    chainId: CosmosNetworkIds
-    endpoints?: {
-      rpcUrl?: string
-      restUrl?: string
-    }
-  }) {
-    super()
-
-    this.contract = contract
-    this.registry = new Registry()
-    this.chainId = chainId
-    this.endpoints = endpoints
-  }
-
-  private transformRSVSignature(rsvSignature: RSVSignature): Uint8Array {
-    return new Uint8Array([
-      ...fromHex(rsvSignature.r),
-      ...fromHex(rsvSignature.s),
-    ])
-  }
-
-  private async getChainInfo(): Promise<ChainInfo> {
-    return {
-      ...(await fetchChainInfo(this.chainId)),
-      ...this.endpoints,
-    }
-  }
-
-  async getBalance(
-    address: string
-  ): Promise<{ balance: bigint; decimals: number }> {
-    try {
-      const { restUrl, denom, decimals } = await this.getChainInfo()
-
-      const response = await fetch(
-        `${restUrl}/cosmos/bank/v1beta1/balances/${address}`
-      )
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`)
-      }
-
-      const data = (await response.json()) as BalanceResponse
-      const balance = data.balances.find((b) => b.denom === denom)
-      const amount = balance?.amount ?? '0'
-
-      return {
-        balance: BigInt(amount),
-        decimals,
-      }
-    } catch (error) {
-      console.error('Failed to fetch Cosmos balance:', error)
-      throw new Error('Failed to fetch Cosmos balance')
-    }
-  }
-
-  async deriveAddressAndPublicKey(
-    predecessor: string,
-    path: KeyDerivationPath
-  ): Promise<{
-    address: string
-    publicKey: string
-  }> {
-    const { prefix } = await this.getChainInfo()
-    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 pubKeySha256 = sha256(fromHex(derivedKey))
-    const ripemd160Hash = ripemd160(pubKeySha256)
-    const address = bech32.encode(prefix, bech32.toWords(ripemd160Hash))
-
-    return { address, publicKey: derivedKey }
-  }
-
-  serializeTransaction(transaction: CosmosUnsignedTransaction): string {
-    const serialized = TxRaw.encode(transaction).finish()
-    return toBase64(serialized)
-  }
-
-  deserializeTransaction(serialized: string): CosmosUnsignedTransaction {
-    return TxRaw.decode(fromBase64(serialized))
-  }
-
-  async prepareTransactionForSigning(
-    transactionRequest: CosmosTransactionRequest
-  ): Promise<{
-    transaction: CosmosUnsignedTransaction
-    hashesToSign: HashToSign[]
-  }> {
-    const { denom, rpcUrl, gasPrice } = await this.getChainInfo()
-    const publicKeyBytes = fromHex(transactionRequest.publicKey)
-
-    const gasLimit = transactionRequest.gas || 200_000
-
-    const fee = calculateFee(
-      gasLimit,
-      GasPrice.fromString(`${gasPrice}${denom}`)
-    )
-
-    const client = await StargateClient.connect(rpcUrl)
-    const accountOnChain = await client.getAccount(transactionRequest.address)
-    if (!accountOnChain) {
-      throw new Error(
-        `Account ${transactionRequest.address} does not exist on chain`
-      )
-    }
-
-    const { accountNumber, sequence } = accountOnChain
-
-    const txBodyEncodeObject: TxBodyEncodeObject = {
-      typeUrl: '/cosmos.tx.v1beta1.TxBody',
-      value: {
-        messages: transactionRequest.messages,
-        memo: transactionRequest.memo || '',
-      },
-    }
-
-    const txBodyBytes = this.registry.encode(txBodyEncodeObject)
-
-    const pubkey = encodePubkey(encodeSecp256k1Pubkey(publicKeyBytes))
-
-    // TODO: Allow caller to provide: multiple signers, fee payer, fee granter
-    const authInfoBytes = makeAuthInfoBytes(
-      [
-        {
-          pubkey,
-          sequence,
-        },
-      ],
-      fee.amount,
-      Number(fee.gas),
-      undefined,
-      undefined,
-      SignMode.SIGN_MODE_DIRECT
-    )
-
-    const signDoc = makeSignDoc(
-      txBodyBytes,
-      authInfoBytes,
-      this.chainId,
-      accountNumber
-    )
-
-    const signBytes = makeSignBytes(signDoc)
-    const payload = Array.from(sha256(signBytes))
-
-    return {
-      transaction: TxRaw.fromPartial({
-        bodyBytes: txBodyBytes,
-        authInfoBytes,
-        signatures: [],
-      }),
-      hashesToSign: [payload],
-    }
-  }
-
-  finalizeTransactionSigning({
-    transaction,
-    rsvSignatures,
-  }: {
-    transaction: CosmosUnsignedTransaction
-    rsvSignatures: RSVSignature[]
-  }): string {
-    // Allow support for multi-sig but the package only supports single-sig
-    transaction.signatures = rsvSignatures.map((sig) =>
-      this.transformRSVSignature(sig)
-    )
-
-    const txBytes = TxRaw.encode(transaction).finish()
-    return Buffer.from(txBytes).toString('hex')
-  }
-
-  async broadcastTx(txSerialized: string): Promise<string> {
-    try {
-      const { rpcUrl } = await this.getChainInfo()
-      const client = await StargateClient.connect(rpcUrl)
-
-      const txBytes = fromHex(txSerialized)
-      const broadcastResponse = await client.broadcastTx(txBytes)
-
-      if (broadcastResponse.code !== 0) {
-        throw new Error(`Broadcast error: ${broadcastResponse.rawLog}`)
-      }
-
-      return broadcastResponse.transactionHash
-    } catch (error) {
-      console.error('Transaction broadcast failed:', error)
-      throw new Error('Failed to broadcast transaction.')
-    }
-  }
-}