signet.js 0.0.7 → 0.0.9-retry

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

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

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

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

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

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

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

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