signet.js 0.0.2 → 0.0.3

package/src/chains/EVM/EVM.ts

@@ -0,0 +1,334 @@
+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 { Chain } from '@chains/Chain'
+import type { BaseChainSignatureContract } from '@chains/ChainSignatureContract'
+import type {
+  EVMTransactionRequest,
+  EVMUnsignedTransaction,
+  EVMMessage,
+  EVMTypedData,
+  UserOperationV6,
+  UserOperationV7,
+} from '@chains/EVM/types'
+import { fetchEVMFeeProperties } from '@chains/EVM/utils'
+import type { HashToSign, 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 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<{
+    hashesToSign: HashToSign[]
+  }> {
+    return {
+      hashesToSign: [Array.from(toBytes(hashMessage(message)))],
+    }
+  }
+
+  async prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
+    hashesToSign: HashToSign[]
+  }> {
+    return {
+      hashesToSign: [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
+    hashesToSign: 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,
+      hashesToSign: [Array.from(toBytes(hashMessage({ raw: userOpHash })))],
+    }
+  }
+
+  attachTransactionSignature({
+    transaction,
+    rsvSignatures,
+  }: {
+    transaction: EVMUnsignedTransaction
+    rsvSignatures: RSVSignature[]
+  }): `0x02${string}` {
+    const signature = this.transformRSVSignature(rsvSignatures[0])
+
+    return serializeTransaction(transaction, signature)
+  }
+
+  assembleMessageSignature({
+    rsvSignatures,
+  }: {
+    rsvSignatures: RSVSignature[]
+  }): Hex {
+    return this.assembleSignature(rsvSignatures[0])
+  }
+
+  assembleTypedDataSignature({
+    rsvSignatures,
+  }: {
+    rsvSignatures: RSVSignature[]
+  }): Hex {
+    return this.assembleSignature(rsvSignatures[0])
+  }
+
+  attachUserOpSignature({
+    userOp,
+    rsvSignatures,
+  }: {
+    userOp: UserOperationV7 | UserOperationV6
+    rsvSignatures: RSVSignature[]
+  }): UserOperationV7 | UserOperationV6 {
+    const { r, s, yParity } = this.transformRSVSignature(rsvSignatures[0])
+    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/chains/EVM/types.ts

@@ -0,0 +1,53 @@
+import type {
+  Address,
+  Hex,
+  TransactionRequest,
+  TypedDataDefinition,
+  SignableMessage,
+} from 'viem'
+
+export type EVMUnsignedTransaction = TransactionRequest & {
+  type: 'eip1559'
+  chainId: number
+}
+
+export interface EVMTransactionRequest
+  extends Omit<EVMUnsignedTransaction, 'chainId' | 'type'> {
+  from: Address
+}
+
+export type EVMMessage = SignableMessage
+
+export type EVMTypedData = TypedDataDefinition
+
+export interface UserOperationV7 {
+  sender: Hex
+  nonce: Hex
+  factory: Hex
+  factoryData: Hex
+  callData: Hex
+  callGasLimit: Hex
+  verificationGasLimit: Hex
+  preVerificationGas: Hex
+  maxFeePerGas: Hex
+  maxPriorityFeePerGas: Hex
+  paymaster: Hex
+  paymasterVerificationGasLimit: Hex
+  paymasterPostOpGasLimit: Hex
+  paymasterData: Hex
+  signature: Hex
+}
+
+export interface UserOperationV6 {
+  sender: Hex
+  nonce: Hex
+  initCode: Hex
+  callData: Hex
+  callGasLimit: Hex
+  verificationGasLimit: Hex
+  preVerificationGas: Hex
+  maxFeePerGas: Hex
+  maxPriorityFeePerGas: Hex
+  paymasterAndData: Hex
+  signature: Hex
+}

package/src/chains/EVM/utils.ts

@@ -0,0 +1,27 @@
+import { type PublicClient, type TransactionRequest } from 'viem'
+
+export interface EVMFeeProperties {
+  gas: bigint
+  maxFeePerGas: bigint
+  maxPriorityFeePerGas: bigint
+}
+
+export async function fetchEVMFeeProperties(
+  client: PublicClient,
+  transaction: TransactionRequest
+): Promise<EVMFeeProperties> {
+  const [gas, feeData] = await Promise.all([
+    client.estimateGas(transaction),
+    client.estimateFeesPerGas(),
+  ])
+
+  const maxFeePerGas = feeData.maxFeePerGas ?? BigInt(10_000_000_000) // 10 gwei
+  const maxPriorityFeePerGas =
+    feeData.maxPriorityFeePerGas ?? BigInt(10_000_000_000) // 10 gwei
+
+  return {
+    gas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  }
+}

package/src/chains/index.ts

@@ -0,0 +1,38 @@
+export { Chain } from './Chain'
+export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract'
+export * from './types'
+
+// EVM
+export { EVM } from './EVM/EVM'
+
+export { fetchEVMFeeProperties } from './EVM/utils'
+
+export type {
+  EVMTransactionRequest,
+  EVMUnsignedTransaction,
+  EVMMessage,
+  EVMTypedData,
+} 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,46 @@
+import { type SignArgs } from '@chains/ChainSignatureContract'
+
+export type HashToSign = SignArgs['payload']
+
+type Base58String = string
+
+export type NajPublicKey = `secp256k1:${Base58String}`
+
+export type UncompressedPubKeySEC1 = `04${string}`
+
+export type CompressedPubKeySEC1 = `02${string}` | `03${string}`
+
+export type KeyDerivationPath = string
+
+export interface RSVSignature {
+  r: string
+  s: string
+  v: number
+}
+
+export interface NearNearMpcSignature {
+  big_r: {
+    affine_point: string
+  }
+  s: {
+    scalar: string
+  }
+  recovery_id: number
+}
+
+export interface SigNetNearMpcSignature {
+  big_r: string
+  s: string
+  recovery_id: number
+}
+
+export interface SigNetEvmMpcSignature {
+  bigR: { x: bigint; y: bigint }
+  s: bigint
+  recoveryId: number
+}
+
+export type MPCSignature =
+  | NearNearMpcSignature
+  | SigNetNearMpcSignature
+  | SigNetEvmMpcSignature

package/src/index.ts

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