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

package/src/chains/Cosmos/Cosmos.ts

@@ -0,0 +1,279 @@
+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 type {
+  CosmosNetworkIds,
+  CosmosTransactionRequest,
+  CosmosUnsignedTransaction,
+} from '@chains/Cosmos/types'
+import type { ChainSignatureContract } from '@chains/ChainSignatureContract'
+import type {
+  MPCPayloads,
+  RSVSignature,
+  KeyDerivationPath,
+} from '@chains/types'
+import { Chain } from '@chains/Chain'
+import { utils } from '@chains'
+import type { ChainInfo, BalanceResponse } from '@chains/Cosmos/types'
+import { fetchChainInfo } from '@chains/Cosmos/utils'
+
+/**
+ * Implementation of the Chain interface for Cosmos-based networks.
+ * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+ */
+export class Cosmos extends Chain<
+  CosmosTransactionRequest,
+  CosmosUnsignedTransaction
+> {
+  private readonly registry: Registry
+  private readonly chainId: CosmosNetworkIds
+  private readonly contract: ChainSignatureContract
+  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: ChainSignatureContract
+    chainId: CosmosNetworkIds
+    endpoints?: {
+      rpcUrl?: string
+      restUrl?: string
+    }
+  }) {
+    super()
+
+    this.contract = contract
+    this.registry = new Registry()
+    this.chainId = chainId
+    this.endpoints = endpoints
+  }
+
+  private parseRSVSignature(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<string> {
+    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'
+
+      const formattedBalance = (
+        parseInt(amount) / Math.pow(10, decimals)
+      ).toString()
+      return formattedBalance
+    } 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 = utils.compressPubKey(uncompressedPubKey)
+    const pubKeySha256 = sha256(fromHex(derivedKey))
+    const ripemd160Hash = ripemd160(pubKeySha256)
+    const address = bech32.encode(prefix, bech32.toWords(ripemd160Hash))
+
+    return { address, publicKey: derivedKey }
+  }
+
+  setTransaction(
+    transaction: CosmosUnsignedTransaction,
+    storageKey: string
+  ): void {
+    const serialized = TxRaw.encode(transaction).finish()
+    window.localStorage.setItem(storageKey, toBase64(serialized))
+  }
+
+  getTransaction(
+    storageKey: string,
+    options?: {
+      remove?: boolean
+    }
+  ): CosmosUnsignedTransaction | undefined {
+    const serialized = window.localStorage.getItem(storageKey)
+    if (!serialized) return undefined
+
+    if (options?.remove) {
+      window.localStorage.removeItem(storageKey)
+    }
+
+    return TxRaw.decode(fromBase64(serialized))
+  }
+
+  async getMPCPayloadAndTransaction(
+    transactionRequest: CosmosTransactionRequest
+  ): Promise<{
+    transaction: CosmosUnsignedTransaction
+    mpcPayloads: MPCPayloads
+  }> {
+    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: [],
+      }),
+      mpcPayloads: [
+        {
+          index: 0,
+          payload,
+        },
+      ],
+    }
+  }
+
+  addSignature({
+    transaction,
+    mpcSignatures,
+  }: {
+    transaction: CosmosUnsignedTransaction
+    mpcSignatures: RSVSignature[]
+  }): string {
+    // Allow support for multi-sig but the package only supports single-sig
+    transaction.signatures = mpcSignatures.map((sig) =>
+      this.parseRSVSignature(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.')
+    }
+  }
+}

package/src/chains/Cosmos/types.ts

@@ -0,0 +1,35 @@
+import { type EncodeObject } from '@cosmjs/proto-signing'
+import { type TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx'
+
+export type CosmosNetworkIds = string
+
+export type CosmosUnsignedTransaction = TxRaw
+
+export interface CosmosTransactionRequest {
+  address: string
+  publicKey: string
+  messages: EncodeObject[]
+  memo?: string
+  gas?: number
+}
+
+export interface BalanceResponse {
+  balances: Array<{
+    denom: string
+    amount: string
+  }>
+  pagination: {
+    next_key: string | null
+    total: string
+  }
+}
+
+export interface ChainInfo {
+  prefix: string
+  denom: string
+  rpcUrl: string
+  restUrl: string
+  expectedChainId: string
+  gasPrice: number
+  decimals: number
+}

package/src/chains/Cosmos/utils.ts

@@ -0,0 +1,45 @@
+import { chains, assets } from 'chain-registry'
+
+import { type ChainInfo } from '@chains/Cosmos/types'
+
+export const fetchChainInfo = async (chainId: string): Promise<ChainInfo> => {
+  const chainInfo = chains.find((chain) => chain.chain_id === chainId)
+  if (!chainInfo) {
+    throw new Error(`Chain info not found for chainId: ${chainId}`)
+  }
+
+  const { bech32_prefix: prefix, chain_id: expectedChainId } = chainInfo
+  const denom = chainInfo.staking?.staking_tokens?.[0]?.denom
+  const rpcUrl = chainInfo.apis?.rpc?.[0]?.address
+  const restUrl = chainInfo.apis?.rest?.[0]?.address
+  const gasPrice = chainInfo.fees?.fee_tokens?.[0]?.average_gas_price
+
+  if (
+    !prefix ||
+    !denom ||
+    !rpcUrl ||
+    !restUrl ||
+    !expectedChainId ||
+    gasPrice === undefined
+  ) {
+    throw new Error(
+      `Missing required chain information for ${chainInfo.chain_name}`
+    )
+  }
+
+  const assetList = assets.find(
+    (asset) => asset.chain_name === chainInfo.chain_name
+  )
+  const asset = assetList?.assets.find((asset) => asset.base === denom)
+  const decimals = asset?.denom_units.find(
+    (unit) => unit.denom === asset.display
+  )?.exponent
+
+  if (decimals === undefined) {
+    throw new Error(
+      `Could not find decimals for ${denom} on chain ${chainInfo.chain_name}`
+    )
+  }
+
+  return { prefix, denom, rpcUrl, restUrl, expectedChainId, gasPrice, decimals }
+}

package/src/chains/EVM/EVM.ts

@@ -0,0 +1,180 @@
+import { fromHex } from '@cosmjs/encoding'
+import { ethers, keccak256 } from 'ethers'
+
+import { Chain } from '@chains/Chain'
+import type { ChainSignatureContract } from '@chains/ChainSignatureContract'
+import type {
+  EVMTransactionRequest,
+  EVMUnsignedTransaction,
+} from '@chains/EVM/types'
+import { fetchEVMFeeProperties } from '@chains/EVM/utils'
+import type {
+  MPCPayloads,
+  RSVSignature,
+  KeyDerivationPath,
+} from '@chains/types'
+
+/**
+ * Implementation of the Chain interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+export class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
+  private readonly provider: ethers.JsonRpcProvider
+  private readonly contract: ChainSignatureContract
+
+  /**
+   * Creates a new EVM chain instance
+   * @param params - Configuration parameters
+   * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
+   * @param params.contract - Instance of the chain signature contract for MPC operations
+   */
+  constructor({
+    rpcUrl,
+    contract,
+  }: {
+    rpcUrl: string
+    contract: ChainSignatureContract
+  }) {
+    super()
+
+    this.contract = contract
+    this.provider = new ethers.JsonRpcProvider(rpcUrl)
+  }
+
+  private async attachGasAndNonce(
+    transaction: EVMTransactionRequest
+  ): Promise<EVMUnsignedTransaction> {
+    const fees = await fetchEVMFeeProperties(
+      this.provider._getConnection().url,
+      transaction
+    )
+    const nonce = await this.provider.getTransactionCount(
+      transaction.from,
+      'latest'
+    )
+
+    const { from, ...rest } = transaction
+
+    return {
+      ...fees,
+      chainId: this.provider._network.chainId,
+      nonce,
+      type: 2,
+      ...rest,
+    }
+  }
+
+  private parseSignature(signature: RSVSignature): ethers.SignatureLike {
+    return ethers.Signature.from({
+      r: `0x${signature.r}`,
+      s: `0x${signature.s}`,
+      v: signature.v,
+    })
+  }
+
+  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 publicKeyNoPrefix = uncompressedPubKey.startsWith('04')
+      ? uncompressedPubKey.substring(2)
+      : uncompressedPubKey
+
+    const hash = ethers.keccak256(fromHex(publicKeyNoPrefix))
+
+    return {
+      address: `0x${hash.substring(hash.length - 40)}`,
+      publicKey: uncompressedPubKey,
+    }
+  }
+
+  async getBalance(address: string): Promise<string> {
+    try {
+      const balance = await this.provider.getBalance(address)
+      return ethers.formatEther(balance)
+    } catch (error) {
+      console.error(`Failed to fetch balance for address ${address}:`, error)
+      throw new Error('Failed to fetch balance.')
+    }
+  }
+
+  setTransaction(
+    transaction: EVMUnsignedTransaction,
+    storageKey: string
+  ): void {
+    const serializedTransaction = JSON.stringify(transaction, (_, value) =>
+      typeof value === 'bigint' ? value.toString() : value
+    )
+    window.localStorage.setItem(storageKey, serializedTransaction)
+  }
+
+  getTransaction(
+    storageKey: string,
+    options?: {
+      remove?: boolean
+    }
+  ): EVMUnsignedTransaction | undefined {
+    const txSerialized = window.localStorage.getItem(storageKey)
+    if (options?.remove) {
+      window.localStorage.removeItem(storageKey)
+    }
+    return txSerialized ? JSON.parse(txSerialized) : undefined
+  }
+
+  async getMPCPayloadAndTransaction(
+    transactionRequest: EVMTransactionRequest
+  ): Promise<{
+    transaction: EVMUnsignedTransaction
+    mpcPayloads: MPCPayloads
+  }> {
+    const transaction = await this.attachGasAndNonce(transactionRequest)
+    const txSerialized = ethers.Transaction.from(transaction).unsignedSerialized
+    const transactionHash = keccak256(txSerialized)
+    const txHash = Array.from(ethers.getBytes(transactionHash))
+
+    return {
+      transaction,
+      mpcPayloads: [
+        {
+          index: 0,
+          payload: txHash,
+        },
+      ],
+    }
+  }
+
+  addSignature({
+    transaction,
+    mpcSignatures,
+  }: {
+    transaction: EVMUnsignedTransaction
+    mpcSignatures: RSVSignature[]
+  }): string {
+    return ethers.Transaction.from({
+      ...transaction,
+      signature: this.parseSignature(mpcSignatures[0]),
+    }).serialized
+  }
+
+  async broadcastTx(txSerialized: string): Promise<string> {
+    try {
+      const txResponse = await this.provider.broadcastTransaction(txSerialized)
+      return txResponse.hash
+    } catch (error) {
+      console.error('Transaction broadcast failed:', error)
+      throw new Error('Failed to broadcast transaction.')
+    }
+  }
+}

package/src/chains/EVM/types.ts

@@ -0,0 +1,7 @@
+import type * as ethers from 'ethers'
+
+export type EVMUnsignedTransaction = ethers.TransactionLike
+
+export type EVMTransactionRequest = Omit<ethers.TransactionLike, 'from'> & {
+  from: string
+}

package/src/chains/EVM/utils.ts

@@ -0,0 +1,26 @@
+import { ethers } from 'ethers'
+
+export async function fetchEVMFeeProperties(
+  providerUrl: string,
+  transaction: ethers.TransactionLike
+): Promise<{
+  gasLimit: bigint
+  maxFeePerGas: bigint
+  maxPriorityFeePerGas: bigint
+  maxFee: bigint
+}> {
+  const provider = new ethers.JsonRpcProvider(providerUrl)
+  const gasLimit = await provider.estimateGas(transaction)
+  const feeData = await provider.getFeeData()
+
+  const maxFeePerGas = feeData.maxFeePerGas ?? ethers.parseUnits('10', 'gwei')
+  const maxPriorityFeePerGas =
+    feeData.maxPriorityFeePerGas ?? ethers.parseUnits('10', 'gwei')
+
+  return {
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    maxFee: maxFeePerGas * gasLimit,
+  }
+}

package/src/chains/index.ts

@@ -0,0 +1,34 @@
+export { Chain } from './Chain'
+export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract'
+export * from './types'
+export * as utils from './utils'
+
+// EVM
+export { EVM } from './EVM/EVM'
+
+export { fetchEVMFeeProperties } from './EVM/utils'
+
+export type { EVMTransactionRequest, EVMUnsignedTransaction } from './EVM/types'
+
+// Bitcoin
+export { Bitcoin } from './Bitcoin/Bitcoin'
+
+export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter'
+
+export type {
+  BTCTransactionRequest,
+  BTCUnsignedTransaction,
+  BTCTransaction,
+  BTCOutput,
+  BTCInput,
+  BTCNetworkIds,
+} from './Bitcoin/types'
+
+// Cosmos
+export { Cosmos } from './Cosmos/Cosmos'
+
+export type {
+  CosmosNetworkIds,
+  CosmosTransactionRequest,
+  CosmosUnsignedTransaction,
+} from './Cosmos/types'

package/src/chains/types.ts

@@ -0,0 +1,35 @@
+import { type SignArgs } from '@chains/ChainSignatureContract'
+
+interface SuccessResponse {
+  transactionHash: string
+  success: true
+}
+
+interface FailureResponse {
+  success: false
+  errorMessage: string
+}
+
+export type Response = SuccessResponse | FailureResponse
+
+export type MPCPayloads = Array<{ index: number; payload: SignArgs['payload'] }>
+
+export type UncompressedPubKeySEC1 = `04${string}`
+
+export type KeyDerivationPath = string
+
+export interface RSVSignature {
+  r: string
+  s: string
+  v: number
+}
+
+export interface MPCSignature {
+  big_r: {
+    affine_point: string
+  }
+  s: {
+    scalar: string
+  }
+  recovery_id: number
+}

package/src/chains/utils.ts

@@ -0,0 +1,40 @@
+import {
+  type MPCSignature,
+  type RSVSignature,
+  type UncompressedPubKeySEC1,
+} from '@chains/types'
+
+export const toRSV = (signature: MPCSignature): RSVSignature => {
+  return {
+    r: signature.big_r.affine_point.substring(2),
+    s: signature.s.scalar,
+    v: signature.recovery_id,
+  }
+}
+
+/**
+ * Compresses an uncompressed public key to its compressed format following SEC1 standards.
+ * In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
+ * The prefix indicates whether the y-coordinate is even (02) or odd (03).
+ *
+ * @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
+ * @returns The compressed public key in hex format
+ * @throws Error if the uncompressed public key length is invalid
+ */
+export const compressPubKey = (
+  uncompressedPubKeySEC1: UncompressedPubKeySEC1
+): string => {
+  const slicedPubKey = uncompressedPubKeySEC1.slice(2)
+
+  if (slicedPubKey.length !== 128) {
+    throw new Error('Invalid uncompressed public key length')
+  }
+
+  const x = slicedPubKey.slice(0, 64)
+  const y = slicedPubKey.slice(64)
+
+  const isEven = parseInt(y.slice(-1), 16) % 2 === 0
+  const prefix = isEven ? '02' : '03'
+
+  return prefix + x
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as utils from './utils'
+export * from './chains'

package/src/utils/chains/index.ts

@@ -0,0 +1 @@
+export * as near from './near'