signet.js 0.0.6 → 0.0.7

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

@@ -0,0 +1,5 @@
+export { ChainAdapter } from './ChainAdapter'
+
+export * as evm from './EVM'
+export * as btc from './Bitcoin'
+export * as cosmos from './Cosmos'

package/src/constants.ts

@@ -0,0 +1,62 @@
+import { type NajPublicKey } from '@types'
+
+export const ENVS = {
+  TESTNET_DEV: 'TESTNET_DEV',
+  TESTNET: 'TESTNET',
+  MAINNET: 'MAINNET',
+} as const
+
+export const CHAINS = {
+  ETHEREUM: 'ETHEREUM',
+  NEAR: 'NEAR',
+} as const
+
+/**
+ * Root public keys for the Sig Network Smart Contracts across different environments.
+ *
+ * These keys should never change.
+ */
+export const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey> = {
+  [ENVS.TESTNET_DEV]:
+    'secp256k1:54hU5wcCmVUPFWLDALXMh1fFToZsVXrx9BbTbHzSfQq1Kd1rJZi52iPa4QQxo6s5TgjWqgpY8HamYuUDzG6fAaUq',
+  [ENVS.TESTNET]:
+    'secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5',
+  [ENVS.MAINNET]:
+    'secp256k1:4tY4qMzusmgX5wYdG35663Y3Qar3CTbpApotwk9ZKLoF79XA4DjG8XoByaKdNHKQX9Lz5hd7iJqsWdTKyA7dKa6Z',
+}
+
+/**
+ * Chain IDs used in the key derivation function (KDF) for deriving child public keys to
+ * distinguish between different chains.
+ *
+ * @see {@link deriveChildPublicKey} in cryptography.ts for usage details
+ */
+export const KDF_CHAIN_IDS = {
+  [CHAINS.ETHEREUM]: '0x1',
+  [CHAINS.NEAR]: '0x18d',
+} as const
+
+/**
+ * Contract addresses for different chains and environments.
+ *
+ * - Testnet Dev: Used for internal development, very unstable
+ * - Testnet: Used for external development, stable
+ * - Mainnet: Production contract address
+ *
+ * @see ChainSignatureContract documentation for implementation details
+ */
+export const CONTRACT_ADDRESSES: Record<
+  keyof typeof CHAINS,
+  Record<keyof typeof ENVS, string>
+> = {
+  [CHAINS.NEAR]: {
+    [ENVS.TESTNET_DEV]: 'dev.sig-net.testnet',
+    [ENVS.TESTNET]: 'v1.sig-net.testnet',
+    [ENVS.MAINNET]: 'v1.sig-net.near',
+  },
+  [CHAINS.ETHEREUM]: {
+    [ENVS.TESTNET_DEV]: '0x69C6b28Fdc74618817fa380De29a653060e14009',
+    [ENVS.TESTNET]: '0x83458E8Bf8206131Fe5c05127007FA164c0948A2',
+    [ENVS.MAINNET]: '0xf8bdC0612361a1E49a8E01423d4C0cFc5dF4791A',
+  },
+}

package/src/contracts/ChainSignatureContract.ts

@@ -0,0 +1,65 @@
+import type BN from 'bn.js'
+
+import type { RSVSignature, UncompressedPubKeySEC1 } from '@types'
+
+export interface SignArgs {
+  /** The payload to sign as an array of 32 bytes */
+  payload: number[]
+  /** The derivation path for key generation */
+  path: string
+  /** Version of the key to use */
+  key_version: number
+}
+
+/**
+ * Base contract interface required for compatibility with ChainAdapter instances like EVM and Bitcoin.
+ *
+ * See {@link EVM} and {@link Bitcoin} for example implementations.
+ */
+export abstract class BaseChainSignatureContract {
+  /**
+   * Gets the current signature deposit required by the contract.
+   * This deposit amount helps manage network congestion.
+   *
+   * @returns Promise resolving to the required deposit amount as a BigNumber
+   */
+  abstract getCurrentSignatureDeposit(): Promise<BN>
+
+  /**
+   * Derives a child public key using a\ derivation path and predecessor.
+   *
+   * @param args - Arguments for key derivation
+   * @param args.path - The string path to use derive the key
+   * @param args.predecessor - The id/address of the account requesting signature
+   * @returns Promise resolving to the derived SEC1 uncompressed public key
+   */
+  abstract getDerivedPublicKey(
+    args: {
+      path: string
+      predecessor: string
+    } & Record<string, unknown>
+  ): Promise<UncompressedPubKeySEC1>
+}
+
+/**
+ * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
+ */
+export abstract class ChainSignatureContract extends BaseChainSignatureContract {
+  /**
+   * Signs a payload using Sig Network MPC.
+   *
+   * @param args - Arguments for the signing operation
+   * @param args.payload - The data to sign as an array of 32 bytes
+   * @param args.path - The string path to use derive the key
+   * @param args.key_version - Version of the key to use
+   * @returns Promise resolving to the RSV signature
+   */
+  abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>
+
+  /**
+   * Gets the public key associated with this contract instance.
+   *
+   * @returns Promise resolving to the SEC1 uncompressed public key
+   */
+  abstract getPublicKey(): Promise<UncompressedPubKeySEC1>
+}

package/src/contracts/evm/ChainSignaturesContract.ts

@@ -0,0 +1,323 @@
+import { najToUncompressedPubKeySEC1 } from '@utils/cryptography'
+import { getRootPublicKey } from '@utils/publicKey'
+import BN from 'bn.js'
+import { withRetry, type PublicClient, type WalletClient, type Hex } from 'viem'
+
+import { CHAINS, KDF_CHAIN_IDS } from '@constants'
+import { ChainSignatureContract as AbstractChainSignatureContract } from '@contracts/ChainSignatureContract'
+import type { SignArgs } from '@contracts/ChainSignatureContract'
+import type {
+  NajPublicKey,
+  RSVSignature,
+  SigNetEvmMpcSignature,
+  UncompressedPubKeySEC1,
+} from '@types'
+import { cryptography } from '@utils'
+
+import { abi } from './ChainSignaturesContractABI'
+import {
+  SignatureNotFoundError,
+  SignatureContractError,
+  SigningError,
+} from './errors'
+import type {
+  RequestIdArgs,
+  SignOptions,
+  SignRequest,
+  SignatureErrorData,
+} from './types'
+import { getRequestId } from './utils'
+
+/**
+ * Implementation of the ChainSignatureContract for EVM chains.
+ *
+ * When signing data, the contract emits a SignatureRequested event with a requestId.
+ * This requestId is used to track the signature request and retrieve the signature
+ * once it's available. The sign method handles this process automatically by polling
+ * for the signature using the requestId.
+ */
+export class ChainSignatureContract extends AbstractChainSignatureContract {
+  private readonly publicClient: PublicClient
+  private readonly walletClient: WalletClient
+  private readonly contractAddress: Hex
+  private readonly rootPublicKey: NajPublicKey
+
+  /**
+   * Creates a new instance of the ChainSignatureContract for EVM chains.
+   *
+   * @param args - Configuration options for the contract
+   * @param args.publicClient - A Viem PublicClient instance for reading from the blockchain
+   * @param args.walletClient - A Viem WalletClient instance for sending transactions
+   * @param args.contractAddress - The address of the deployed ChainSignatures contract (e.g. `0x857ED3A242B59cC24144814a0DF41C397a3811E6`)
+   * @param args.rootPublicKey - Optional root public key. If not provided, it will be derived from the contract address
+   */
+  constructor(args: {
+    publicClient: PublicClient
+    walletClient: WalletClient
+    contractAddress: Hex
+    rootPublicKey?: NajPublicKey
+  }) {
+    super()
+    this.publicClient = args.publicClient
+    this.walletClient = args.walletClient
+    this.contractAddress = args.contractAddress
+
+    const rootPublicKey =
+      args.rootPublicKey ||
+      getRootPublicKey(this.contractAddress, CHAINS.ETHEREUM)
+
+    if (!rootPublicKey) {
+      throw new Error(
+        `Invalid public key, please provide a valid root public key or contract address`
+      )
+    }
+
+    this.rootPublicKey = rootPublicKey
+  }
+
+  async getCurrentSignatureDeposit(): Promise<BN> {
+    const deposit = (await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi,
+      functionName: 'getSignatureDeposit',
+    })) as bigint
+
+    return new BN(deposit.toString())
+  }
+
+  async getDerivedPublicKey(args: {
+    path: string
+    predecessor: string
+  }): Promise<UncompressedPubKeySEC1> {
+    const pubKey = cryptography.deriveChildPublicKey(
+      await this.getPublicKey(),
+      args.predecessor.toLowerCase(),
+      args.path,
+      KDF_CHAIN_IDS.ETHEREUM
+    )
+
+    return pubKey
+  }
+
+  async getPublicKey(): Promise<UncompressedPubKeySEC1> {
+    return najToUncompressedPubKeySEC1(this.rootPublicKey)
+  }
+
+  async getLatestKeyVersion(): Promise<number> {
+    const version = (await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi,
+      functionName: 'latestKeyVersion',
+    })) as bigint
+
+    return Number(version)
+  }
+
+  /**
+   * Sends a transaction to the contract to request a signature, then
+   * polls for the signature result. If the signature is not found within the retry
+   * parameters, it will throw an error.
+   */
+  async sign(
+    args: SignArgs,
+    options: SignOptions = {
+      sign: {
+        algo: '',
+        dest: '',
+        params: '',
+      },
+      retry: {
+        delay: 5000,
+        retryCount: 12,
+      },
+    }
+  ): Promise<RSVSignature> {
+    if (!this.walletClient?.account) {
+      throw new Error('Wallet client required for signing operations')
+    }
+
+    const request: SignRequest = {
+      payload: `0x${Buffer.from(args.payload).toString('hex')}`,
+      path: args.path,
+      keyVersion: args.key_version,
+      algo: options.sign.algo ?? '',
+      dest: options.sign.dest ?? '',
+      params: options.sign.params ?? '',
+    }
+
+    const requestId = this.getRequestId({
+      ...request,
+      address: this.walletClient.account.address,
+      chainId: this.publicClient.chain?.id
+        ? BigInt(this.publicClient.chain.id)
+        : 0n,
+    })
+
+    const hash = await this.walletClient.writeContract({
+      address: this.contractAddress,
+      abi,
+      chain: this.publicClient.chain,
+      account: this.walletClient.account,
+      functionName: 'sign',
+      args: [request],
+      value: BigInt((await this.getCurrentSignatureDeposit()).toString()),
+    })
+
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash })
+
+    try {
+      const result = await withRetry(
+        async () => {
+          const result = await this.getSignatureFromEvents(
+            requestId,
+            receipt.blockNumber
+          )
+
+          // TODO: Validate if this is the signature corresponding to the transaction as anybody can call respond on the contract
+
+          if (result) {
+            return result
+          } else {
+            throw new Error('Signature not found yet')
+          }
+        },
+        {
+          delay: options.retry.delay,
+          retryCount: options.retry.retryCount,
+          shouldRetry: ({ count, error }) => {
+            // TODO: Should be enabled only on debug mode
+            console.log(
+              `Retrying get signature: ${count}/${options.retry.retryCount}`
+            )
+            return error.message === 'Signature not found yet'
+          },
+        }
+      )
+
+      if (result) {
+        return result
+      } else {
+        const errorData = await this.getErrorFromEvents(
+          requestId,
+          receipt.blockNumber
+        )
+        if (errorData) {
+          throw new SignatureContractError(errorData.error, requestId, receipt)
+        } else {
+          throw new SignatureNotFoundError(requestId, receipt)
+        }
+      }
+    } catch (error) {
+      if (
+        error instanceof SignatureNotFoundError ||
+        error instanceof SignatureContractError
+      ) {
+        throw error
+      } else {
+        throw new SigningError(
+          requestId,
+          receipt,
+          error instanceof Error ? error : undefined
+        )
+      }
+    }
+  }
+
+  /**
+   * Generates the request ID for a signature request allowing to track the response.
+   *
+   * @param request - The signature request object containing:
+   *   @param request.address - The contract/wallet address calling the signing contract
+   *   @param request.payload - The data payload to be signed as a hex string
+   *   @param request.path - The derivation path for the key
+   *   @param request.keyVersion - The version of the key to use
+   *   @param request.chainId - The chain ID as a bigint
+   *   @param request.algo - The signing algorithm to use
+   *   @param request.dest - The destination for the signature
+   *   @param request.params - Additional parameters for the signing process
+   * @returns A hex string representing the unique request ID
+   *
+   * @example
+   * ```typescript
+   * const requestId = ChainSignatureContract.getRequestId({
+   *   address: walletClient.account.address,
+   *   payload: payload: `0x${Buffer.from(args.payload).toString('hex')}`,,
+   *   path: '',
+   *   keyVersion: 0,
+   *   chainId: 1n,
+   *   algo: '',
+   *   dest: '',
+   *   params: ''
+   * });
+   * console.log(requestId); // 0x...
+   * ```
+   */
+  getRequestId(request: RequestIdArgs): Hex {
+    return getRequestId(request)
+  }
+
+  async getErrorFromEvents(
+    requestId: Hex,
+    fromBlock: bigint
+  ): Promise<SignatureErrorData | undefined> {
+    const errorLogs = await this.publicClient.getContractEvents({
+      address: this.contractAddress,
+      abi,
+      eventName: 'SignatureError',
+      args: {
+        requestId,
+      },
+      fromBlock,
+      toBlock: 'latest',
+    })
+
+    if (errorLogs.length > 0) {
+      const { args: errorData } = errorLogs[
+        errorLogs.length - 1
+      ] as unknown as {
+        args: SignatureErrorData
+      }
+
+      return errorData
+    }
+
+    return undefined
+  }
+
+  /**
+   * Searches for SignatureResponded events that match the given requestId.
+   * It works in conjunction with the getRequestId method which generates the unique
+   * identifier for a signature request.
+   *
+   * @param requestId - The identifier for the signature request
+   * @param fromBlock - The block number to start searching from
+   * @returns The RSV signature if found, undefined otherwise
+   */
+  async getSignatureFromEvents(
+    requestId: Hex,
+    fromBlock: bigint
+  ): Promise<RSVSignature | undefined> {
+    const logs = await this.publicClient.getContractEvents({
+      address: this.contractAddress,
+      abi,
+      eventName: 'SignatureResponded',
+      args: {
+        requestId,
+      },
+      fromBlock,
+      toBlock: 'latest',
+    })
+
+    if (logs.length > 0) {
+      const { args: signatureData } = logs[logs.length - 1] as unknown as {
+        args: {
+          signature: SigNetEvmMpcSignature
+        }
+      }
+
+      return cryptography.toRSV(signatureData.signature)
+    }
+
+    return undefined
+  }
+}