signet.js 0.0.2 → 0.0.3

package/src/chains/Cosmos/Cosmos.ts

@@ -0,0 +1,258 @@
+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 { Chain } from '@chains/Chain'
+import type { BaseChainSignatureContract } from '@chains/ChainSignatureContract'
+import type {
+  CosmosNetworkIds,
+  CosmosTransactionRequest,
+  CosmosUnsignedTransaction,
+  ChainInfo,
+  BalanceResponse,
+} from '@chains/Cosmos/types'
+import { fetchChainInfo } from '@chains/Cosmos/utils'
+import type { HashToSign, RSVSignature, KeyDerivationPath } from '@chains/types'
+import { cryptography } from '@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: 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],
+    }
+  }
+
+  attachTransactionSignature({
+    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.')
+    }
+  }
+}

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.test.ts

@@ -0,0 +1,238 @@
+import { LocalAccountSigner } from '@aa-sdk/core'
+import { alchemy, sepolia as alchemySepolia } from '@account-kit/infra'
+import { createLightAccountAlchemyClient } from '@account-kit/smart-contracts'
+import { secp256k1 } from '@noble/curves/secp256k1'
+import BN from 'bn.js'
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseEther,
+  recoverMessageAddress,
+  recoverTypedDataAddress,
+} from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { hardhat } from 'viem/chains'
+import { describe, expect, it } from 'vitest'
+
+import type { ChainSignatureContract } from '../ChainSignatureContract'
+import type { UncompressedPubKeySEC1 } from '../types'
+
+import { EVM } from './EVM'
+
+describe('EVM', async () => {
+  const privateKey =
+    '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+  const testAccount = privateKeyToAccount(privateKey)
+  const rpcUrl = 'http://127.0.0.1:8545'
+
+  const publicClient = createPublicClient({
+    chain: hardhat,
+    transport: http(rpcUrl),
+  })
+
+  const walletClient = createWalletClient({
+    account: testAccount,
+    chain: hardhat,
+    transport: http(rpcUrl),
+  })
+
+  const contract: ChainSignatureContract = {
+    sign: async ({ payload }) => {
+      const messageBytes = new Uint8Array(payload)
+      const privKeyBytes = new Uint8Array(
+        Buffer.from(privateKey.slice(2), 'hex')
+      )
+      const { r, s, recovery } = secp256k1.sign(messageBytes, privKeyBytes)
+      return {
+        r: r.toString(16).padStart(64, '0'),
+        s: s.toString(16).padStart(64, '0'),
+        v: recovery + 27,
+      }
+    },
+    getDerivedPublicKey: async () => {
+      return '04' as UncompressedPubKeySEC1
+    },
+    getPublicKey: async () => {
+      const pubKey = secp256k1.getPublicKey(
+        Buffer.from(privateKey.slice(2), 'hex')
+      )
+      return ('04' +
+        Buffer.from(pubKey.slice(1)).toString('hex')) as UncompressedPubKeySEC1
+    },
+    getCurrentSignatureDeposit: async () => new BN(0),
+  }
+
+  const evm = new EVM({
+    contract,
+    rpcUrl,
+  })
+
+  it('should sign a message', async () => {
+    const message = 'Hello, World!'
+    const { hashesToSign } = await evm.prepareMessageForSigning(message)
+
+    const mpcSignature = await contract.sign({
+      payload: hashesToSign[0],
+      path: '',
+      key_version: 0,
+    })
+
+    const signature = evm.assembleMessageSignature({
+      rsvSignatures: [mpcSignature],
+    })
+
+    const walletSignature = await walletClient.signMessage({
+      message,
+    })
+
+    const recoveredAddress = await recoverMessageAddress({
+      message,
+      signature: walletSignature,
+    })
+
+    expect(recoveredAddress).toBe(testAccount.address)
+    expect(signature).toBe(walletSignature)
+  })
+
+  it('should sign typed data', async () => {
+    const typedData = {
+      domain: {
+        name: 'Test',
+        version: '1',
+        chainId: hardhat.id,
+        verifyingContract:
+          '0x1234567890123456789012345678901234567890' as `0x${string}`,
+      },
+      types: {
+        Person: [
+          { name: 'name', type: 'string' },
+          { name: 'wallet', type: 'address' },
+        ],
+      },
+      primaryType: 'Person' as const,
+      message: {
+        name: 'Bob',
+        wallet: '0x1234567890123456789012345678901234567890' as `0x${string}`,
+      },
+    }
+
+    const { hashesToSign } = await evm.prepareTypedDataForSigning(typedData)
+
+    const mpcSignature = await contract.sign({
+      payload: hashesToSign[0],
+      path: '',
+      key_version: 0,
+    })
+
+    const signature = evm.assembleTypedDataSignature({
+      rsvSignatures: [mpcSignature],
+    })
+
+    const walletSignature = await walletClient.signTypedData(typedData)
+
+    const recoveredAddress = await recoverTypedDataAddress({
+      ...typedData,
+      signature: walletSignature,
+    })
+
+    expect(recoveredAddress).toBe(testAccount.address)
+    expect(signature).toBe(walletSignature)
+  })
+
+  it('should sign a transaction', async () => {
+    await publicClient.request({
+      // @ts-expect-error: hardhat_setBalance is valid as we are using a hardhat client
+      method: 'hardhat_setBalance',
+      params: [testAccount.address, '0x4563918244f400000000'], // 5 ETH
+    })
+
+    const transactionInput = {
+      from: testAccount.address,
+      to: '0x1234567890123456789012345678901234567890' as `0x${string}`,
+      value: parseEther('1'),
+      maxFeePerGas: parseEther('0.001'),
+      maxPriorityFeePerGas: parseEther('0.0001'),
+      gas: 21000n,
+      nonce: await publicClient.getTransactionCount({
+        address: testAccount.address,
+      }),
+      type: 'eip1559' as const,
+      chainId: hardhat.id,
+      accessList: [],
+    }
+
+    const { hashesToSign, transaction } =
+      await evm.prepareTransactionForSigning(transactionInput)
+
+    const mpcSignature = await contract.sign({
+      payload: hashesToSign[0],
+      path: '',
+      key_version: 0,
+    })
+
+    const tx = evm.attachTransactionSignature({
+      transaction,
+      rsvSignatures: [mpcSignature],
+    })
+
+    const walletSignature = await walletClient.signTransaction(transactionInput)
+
+    expect(tx).toBe(walletSignature)
+
+    const txHash = await evm.broadcastTx(tx)
+
+    const txReceipt = await publicClient.getTransactionReceipt({
+      hash: txHash,
+    })
+
+    expect(txReceipt.status).toBe('success')
+  })
+
+  it('should sign a user operation', async () => {
+    const lightAccountClient = await createLightAccountAlchemyClient({
+      transport: alchemy({ apiKey: 'er9VowLvLw2YQbgTaRLudG81JPxs77rT' }),
+      chain: alchemySepolia,
+      signer: LocalAccountSigner.privateKeyToAccountSigner(privateKey),
+    })
+
+    const userOp = {
+      sender: testAccount.address,
+      nonce: '0x0' as `0x${string}`,
+      initCode: '0x' as `0x${string}`,
+      callData: '0x' as `0x${string}`,
+      callGasLimit: '0x5208' as `0x${string}`,
+      verificationGasLimit: '0x5208' as `0x${string}`,
+      preVerificationGas: '0x5208' as `0x${string}`,
+      maxFeePerGas: '0x38d7ea4c68000' as `0x${string}`,
+      maxPriorityFeePerGas: '0x5af3107a4000' as `0x${string}`,
+      paymasterAndData: '0x' as `0x${string}`,
+      signature: '0x' as `0x${string}`,
+    }
+
+    const { hashesToSign } = await evm.prepareUserOpForSigning(
+      userOp,
+      '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
+      11155111
+    )
+
+    const mpcSignature = await contract.sign({
+      payload: hashesToSign[0],
+      path: '',
+      key_version: 0,
+    })
+
+    const signedUserOp = evm.attachUserOpSignature({
+      userOp,
+      rsvSignatures: [mpcSignature],
+    })
+
+    const walletSignature = await lightAccountClient.signUserOperation({
+      uoStruct: userOp,
+    })
+
+    expect(signedUserOp.signature).toBe(walletSignature.signature)
+  })
+
+  // TODO: Include test for v7 user operations.
+})