signet.js 0.0.5 → 0.0.7

package/src/chain-adapters/Cosmos/index.ts

@@ -0,0 +1,8 @@
+// Cosmos
+export { Cosmos } from './Cosmos'
+
+export type {
+  CosmosNetworkIds,
+  CosmosTransactionRequest,
+  CosmosUnsignedTransaction,
+} from './types'

package/src/chain-adapters/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/chain-adapters/Cosmos/utils.ts

@@ -0,0 +1,45 @@
+import { chains, assets } from 'chain-registry'
+
+import { type ChainInfo } from '@chain-adapters/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/chain-adapters/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 '../../contracts/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 { hashToSign } = await evm.prepareMessageForSigning(message)
+
+    const mpcSignature = await contract.sign({
+      payload: hashToSign,
+      path: '',
+      key_version: 0,
+    })
+
+    const signature = evm.finalizeMessageSigning({
+      rsvSignature: 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 { hashToSign } = await evm.prepareTypedDataForSigning(typedData)
+
+    const mpcSignature = await contract.sign({
+      payload: hashToSign,
+      path: '',
+      key_version: 0,
+    })
+
+    const signature = evm.finalizeTypedDataSigning({
+      rsvSignature: 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.finalizeTransactionSigning({
+      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 { hashToSign } = await evm.prepareUserOpForSigning(
+      userOp,
+      '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
+      11155111
+    )
+
+    const mpcSignature = await contract.sign({
+      payload: hashToSign,
+      path: '',
+      key_version: 0,
+    })
+
+    const signedUserOp = evm.finalizeUserOpSigning({
+      userOp,
+      rsvSignature: mpcSignature,
+    })
+
+    const walletSignature = await lightAccountClient.signUserOperation({
+      uoStruct: userOp,
+    })
+
+    expect(signedUserOp.signature).toBe(walletSignature.signature)
+  })
+
+  // TODO: Include test for v7 user operations.
+})

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

@@ -0,0 +1,337 @@
+import {
+  createPublicClient,
+  http,
+  parseTransaction,
+  type PublicClient,
+  hashMessage,
+  hashTypedData,
+  keccak256,
+  toBytes,
+  type Hex,
+  serializeTransaction,
+  type Signature,
+  numberToHex,
+  getAddress,
+  type Address,
+  type Hash,
+  concatHex,
+  encodeAbiParameters,
+  hexToBigInt,
+  concat,
+  pad,
+  isAddress,
+} from 'viem'
+
+import { ChainAdapter } from '@chain-adapters/ChainAdapter'
+import type {
+  EVMTransactionRequest,
+  EVMUnsignedTransaction,
+  EVMMessage,
+  EVMTypedData,
+  UserOperationV6,
+  UserOperationV7,
+} from '@chain-adapters/EVM/types'
+import { fetchEVMFeeProperties } from '@chain-adapters/EVM/utils'
+import type { BaseChainSignatureContract } from '@contracts/ChainSignatureContract'
+import type { HashToSign, RSVSignature, KeyDerivationPath } from '@types'
+
+/**
+ * Implementation of the ChainAdapter interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+export class EVM extends ChainAdapter<
+  EVMTransactionRequest,
+  EVMUnsignedTransaction
+> {
+  private readonly client: PublicClient
+  private readonly contract: BaseChainSignatureContract
+
+  /**
+   * 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: BaseChainSignatureContract
+  }) {
+    super()
+
+    this.contract = contract
+    this.client = createPublicClient({
+      transport: http(rpcUrl),
+    })
+  }
+
+  private async attachGasAndNonce(
+    transaction: EVMTransactionRequest
+  ): Promise<EVMUnsignedTransaction> {
+    const fees = await fetchEVMFeeProperties(this.client, transaction)
+    const nonce = await this.client.getTransactionCount({
+      address: transaction.from,
+    })
+
+    const { from, ...rest } = transaction
+
+    return {
+      ...fees,
+      nonce,
+      chainId: Number(await this.client.getChainId()),
+      type: 'eip1559',
+      ...rest,
+    }
+  }
+
+  private transformRSVSignature(signature: RSVSignature): Signature {
+    return {
+      r: `0x${signature.r}`,
+      s: `0x${signature.s}`,
+      yParity: signature.v - 27,
+    }
+  }
+
+  private assembleSignature(signature: RSVSignature): Hex {
+    const { r, s, yParity } = this.transformRSVSignature(signature)
+
+    if (yParity === undefined) {
+      throw new Error('Missing yParity')
+    }
+
+    return concatHex([r, s, numberToHex(yParity + 27, { size: 1 })])
+  }
+
+  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.slice(2)
+      : uncompressedPubKey
+
+    const hash = keccak256(Buffer.from(publicKeyNoPrefix, 'hex'))
+    const address = getAddress(`0x${hash.slice(-40)}`)
+
+    return {
+      address,
+      publicKey: uncompressedPubKey,
+    }
+  }
+
+  async getBalance(
+    address: string
+  ): Promise<{ balance: bigint; decimals: number }> {
+    const balance = await this.client.getBalance({
+      address: address as Address,
+    })
+    return {
+      balance,
+      decimals: 18,
+    }
+  }
+
+  serializeTransaction(transaction: EVMUnsignedTransaction): `0x${string}` {
+    return serializeTransaction(transaction)
+  }
+
+  deserializeTransaction(serialized: `0x${string}`): EVMUnsignedTransaction {
+    return parseTransaction(serialized) as EVMUnsignedTransaction
+  }
+
+  async prepareTransactionForSigning(
+    transactionRequest: EVMTransactionRequest
+  ): Promise<{
+    transaction: EVMUnsignedTransaction
+    hashesToSign: HashToSign[]
+  }> {
+    const transaction = await this.attachGasAndNonce(transactionRequest)
+
+    const serializedTx = serializeTransaction(transaction)
+    const txHash = toBytes(keccak256(serializedTx))
+
+    return {
+      transaction,
+      hashesToSign: [Array.from(txHash)],
+    }
+  }
+
+  async prepareMessageForSigning(message: EVMMessage): Promise<{
+    hashToSign: HashToSign
+  }> {
+    return {
+      hashToSign: Array.from(toBytes(hashMessage(message))),
+    }
+  }
+
+  async prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
+    hashToSign: HashToSign
+  }> {
+    return {
+      hashToSign: Array.from(toBytes(hashTypedData(typedDataRequest))),
+    }
+  }
+
+  /**
+   * This implementation is a common step for Biconomy and Alchemy.
+   * Key differences between implementations:
+   * - Signature format: Biconomy omits 0x00 prefix when concatenating, Alchemy includes it
+   * - Version support: Biconomy only supports v6, Alchemy supports both v6 and v7
+   * - Validation: Biconomy uses modules for signature validation, Alchemy uses built-in validation
+   */
+  async prepareUserOpForSigning(
+    userOp: UserOperationV7 | UserOperationV6,
+    entryPointAddress?: Address,
+    chainIdArgs?: number
+  ): Promise<{
+    userOp: UserOperationV7 | UserOperationV6
+    hashToSign: HashToSign
+  }> {
+    const chainId = chainIdArgs ?? (await this.client.getChainId())
+    const entryPoint =
+      entryPointAddress || '0x0000000071727De22E5E9d8BAf0edAc6f37da032'
+
+    const encoded = encodeAbiParameters(
+      [{ type: 'bytes32' }, { type: 'address' }, { type: 'uint256' }],
+      [
+        keccak256(
+          encodeAbiParameters(
+            [
+              { type: 'address' },
+              { type: 'uint256' },
+              { type: 'bytes32' },
+              { type: 'bytes32' },
+              { type: 'bytes32' },
+              { type: 'uint256' },
+              { type: 'bytes32' },
+              { type: 'bytes32' },
+            ],
+            [
+              userOp.sender,
+              hexToBigInt(userOp.nonce),
+              keccak256(
+                'factory' in userOp &&
+                  'factoryData' in userOp &&
+                  userOp.factory &&
+                  userOp.factoryData
+                  ? concat([userOp.factory, userOp.factoryData])
+                  : 'initCode' in userOp
+                    ? userOp.initCode
+                    : '0x'
+              ),
+              keccak256(userOp.callData),
+              concat([
+                pad(userOp.verificationGasLimit, { size: 16 }),
+                pad(userOp.callGasLimit, { size: 16 }),
+              ]),
+              hexToBigInt(userOp.preVerificationGas),
+              concat([
+                pad(userOp.maxPriorityFeePerGas, { size: 16 }),
+                pad(userOp.maxFeePerGas, { size: 16 }),
+              ]),
+              keccak256(
+                'paymaster' in userOp &&
+                  userOp.paymaster &&
+                  isAddress(userOp.paymaster)
+                  ? concat([
+                      userOp.paymaster,
+                      pad(userOp.paymasterVerificationGasLimit, { size: 16 }),
+                      pad(userOp.paymasterPostOpGasLimit, { size: 16 }),
+                      userOp.paymasterData,
+                    ])
+                  : 'paymasterAndData' in userOp
+                    ? userOp.paymasterAndData
+                    : '0x'
+              ),
+            ]
+          )
+        ),
+        entryPoint,
+        BigInt(chainId),
+      ]
+    )
+
+    const userOpHash = keccak256(encoded)
+
+    return {
+      userOp,
+      hashToSign: Array.from(toBytes(hashMessage({ raw: userOpHash }))),
+    }
+  }
+
+  finalizeTransactionSigning({
+    transaction,
+    rsvSignatures,
+  }: {
+    transaction: EVMUnsignedTransaction
+    rsvSignatures: RSVSignature[]
+  }): `0x02${string}` {
+    const signature = this.transformRSVSignature(rsvSignatures[0])
+
+    return serializeTransaction(transaction, signature)
+  }
+
+  finalizeMessageSigning({
+    rsvSignature,
+  }: {
+    rsvSignature: RSVSignature
+  }): Hex {
+    return this.assembleSignature(rsvSignature)
+  }
+
+  finalizeTypedDataSigning({
+    rsvSignature,
+  }: {
+    rsvSignature: RSVSignature
+  }): Hex {
+    return this.assembleSignature(rsvSignature)
+  }
+
+  finalizeUserOpSigning({
+    userOp,
+    rsvSignature,
+  }: {
+    userOp: UserOperationV7 | UserOperationV6
+    rsvSignature: RSVSignature
+  }): UserOperationV7 | UserOperationV6 {
+    const { r, s, yParity } = this.transformRSVSignature(rsvSignature)
+    if (yParity === undefined) {
+      throw new Error('Missing yParity')
+    }
+
+    return {
+      ...userOp,
+      signature: concatHex([
+        '0x00', // Alchemy specific implementation. Biconomy doesn't include the 0x00 prefix.
+        r,
+        s,
+        numberToHex(Number(yParity + 27), { size: 1 }),
+      ]),
+    }
+  }
+
+  async broadcastTx(txSerialized: `0x${string}`): Promise<Hash> {
+    try {
+      return await this.client.sendRawTransaction({
+        serializedTransaction: txSerialized,
+      })
+    } catch (error) {
+      console.error('Transaction broadcast failed:', error)
+      throw new Error('Failed to broadcast transaction.')
+    }
+  }
+}

package/src/chain-adapters/EVM/index.ts

@@ -0,0 +1,11 @@
+// EVM
+export { EVM } from './EVM'
+
+export { fetchEVMFeeProperties } from './utils'
+
+export type {
+  EVMTransactionRequest,
+  EVMUnsignedTransaction,
+  EVMMessage,
+  EVMTypedData,
+} from './types'