signet.js 0.0.2-beta.6 → 0.0.3

package/src/utils/chains/evm/types.ts

@@ -0,0 +1,28 @@
+import type { Hex } from 'viem'
+
+export interface SignOptions {
+  sign: {
+    algo?: string
+    dest?: string
+    params?: string
+  }
+  retry: {
+    delay?: number
+    retryCount?: number
+  }
+}
+
+export interface SignatureErrorData {
+  requestId: string
+  responder: string
+  error: string
+}
+
+export interface SignRequest {
+  payload: Hex
+  path: string
+  keyVersion: number
+  algo: string
+  dest: string
+  params: string
+}

package/src/utils/chains/evm/utils.ts

@@ -0,0 +1,11 @@
+import * as chains from 'viem/chains'
+import type { Chain } from 'viem/chains'
+
+export const getChain = (chainId: number): Chain => {
+  for (const chain of Object.values(chains)) {
+    if (chain.id === chainId) {
+      return chain
+    }
+  }
+  throw new Error('Chain not found')
+}

package/src/utils/chains/index.ts

@@ -0,0 +1,2 @@
+export * as near from './near'
+export * as evm from './evm'

package/src/utils/chains/near/ChainSignatureContract.ts

@@ -0,0 +1,155 @@
+import { Contract } from '@near-js/accounts'
+import { KeyPair } from '@near-js/crypto'
+import BN from 'bn.js'
+
+import { ChainSignatureContract as AbstractChainSignatureContract } from '@chains/ChainSignatureContract'
+import type { SignArgs } from '@chains/ChainSignatureContract'
+import type {
+  RSVSignature,
+  MPCSignature,
+  UncompressedPubKeySEC1,
+  NajPublicKey,
+} from '@chains/types'
+import { cryptography } from '@utils'
+import { getNearAccount } from '@utils/chains/near/account'
+import {
+  DONT_CARE_ACCOUNT_ID,
+  NEAR_MAX_GAS,
+} from '@utils/chains/near/constants'
+import {
+  type NearNetworkIds,
+  type ChainSignatureContractIds,
+} from '@utils/chains/near/types'
+import { najToUncompressedPubKeySEC1 } from '@utils/cryptography'
+
+const requireAccount = (accountId: string): void => {
+  if (accountId === DONT_CARE_ACCOUNT_ID) {
+    throw new Error(
+      'A valid account ID and keypair are required for change methods. Please instantiate a new contract with valid credentials.'
+    )
+  }
+}
+
+type NearContract = Contract & {
+  public_key: () => Promise<NajPublicKey>
+  sign: (args: {
+    args: { request: SignArgs }
+    gas: BN
+    amount: BN
+  }) => Promise<MPCSignature>
+  experimental_signature_deposit: () => Promise<number>
+  derived_public_key: (args: {
+    path: string
+    predecessor: string
+  }) => Promise<NajPublicKey>
+}
+
+interface ChainSignatureContractArgs {
+  networkId: NearNetworkIds
+  contractId: ChainSignatureContractIds
+  accountId?: string
+  keypair?: KeyPair
+}
+
+/**
+ * Implementation of the ChainSignatureContract for NEAR chains.
+ *
+ * This class provides an interface to interact with the ChainSignatures contract
+ * deployed on NEAR. It supports both view methods (which don't require authentication)
+ * and change methods (which require a valid NEAR account and keypair).
+ *
+ * @extends AbstractChainSignatureContract
+ */
+export class ChainSignatureContract extends AbstractChainSignatureContract {
+  private readonly networkId: NearNetworkIds
+  private readonly contractId: ChainSignatureContractIds
+  private readonly accountId: string
+  private readonly keypair: KeyPair
+
+  /**
+   * Creates a new instance of the ChainSignatureContract for NEAR chains.
+   *
+   * @param args - Configuration options for the contract
+   * @param args.networkId - The NEAR network ID (e.g. 'testnet', 'mainnet')
+   * @param args.contractId - The contract ID of the deployed ChainSignatures contract
+   * @param args.accountId - Optional NEAR account ID for signing transactions. Required for change methods.
+   * @param args.keypair - Optional NEAR KeyPair for signing transactions. Required for change methods.
+   */
+  constructor({
+    networkId,
+    contractId,
+    accountId = DONT_CARE_ACCOUNT_ID,
+    keypair = KeyPair.fromRandom('ed25519'),
+  }: ChainSignatureContractArgs) {
+    // TODO: Should use the hardcoded ROOT_PUBLIC_KEY as in the EVM ChainSignatureContract
+    super()
+
+    this.networkId = networkId
+    this.contractId = contractId
+    this.accountId = accountId
+    this.keypair = keypair
+  }
+
+  private async getContract(): Promise<NearContract> {
+    const account = await getNearAccount({
+      networkId: this.networkId,
+      accountId: this.accountId,
+      keypair: this.keypair,
+    })
+
+    return new Contract(account, this.contractId, {
+      viewMethods: [
+        'public_key',
+        'experimental_signature_deposit',
+        'derived_public_key',
+      ],
+      changeMethods: ['sign'],
+      useLocalViewExecution: false,
+    }) as unknown as NearContract
+  }
+
+  async getCurrentSignatureDeposit(): Promise<BN> {
+    const contract = await this.getContract()
+    return new BN(
+      (await contract.experimental_signature_deposit()).toLocaleString(
+        'fullwide',
+        {
+          useGrouping: false,
+        }
+      )
+    )
+  }
+
+  async getDerivedPublicKey(args: {
+    path: string
+    predecessor: string
+  }): Promise<UncompressedPubKeySEC1> {
+    const contract = await this.getContract()
+
+    const najPubKey = await contract.derived_public_key(args)
+    return najToUncompressedPubKeySEC1(najPubKey)
+  }
+
+  async getPublicKey(): Promise<UncompressedPubKeySEC1> {
+    const contract = await this.getContract()
+
+    const najPubKey = await contract.public_key()
+    return najToUncompressedPubKeySEC1(najPubKey)
+  }
+
+  // TODO: Should call the contract without the Contract instance as it doesn't allow for proper timeout handling on the BE
+  async sign(args: SignArgs): Promise<RSVSignature> {
+    requireAccount(this.accountId)
+
+    const contract = await this.getContract()
+    const deposit = await this.getCurrentSignatureDeposit()
+
+    const signature = await contract.sign({
+      args: { request: args },
+      gas: NEAR_MAX_GAS,
+      amount: deposit,
+    })
+
+    return cryptography.toRSV(signature)
+  }
+}

package/src/utils/chains/near/account.ts

@@ -0,0 +1,42 @@
+import { Account, Connection } from '@near-js/accounts'
+import { KeyPair } from '@near-js/crypto'
+import { InMemoryKeyStore } from '@near-js/keystores'
+
+import { DONT_CARE_ACCOUNT_ID } from '@utils/chains/near/constants'
+
+type SetConnectionArgs =
+  | {
+      networkId: string
+      accountId: string
+      keypair: KeyPair
+    }
+  | {
+      networkId: string
+      accountId?: never
+      keypair?: never
+    }
+
+export const getNearAccount = async ({
+  networkId,
+  accountId = DONT_CARE_ACCOUNT_ID,
+  keypair = KeyPair.fromRandom('ed25519'),
+}: SetConnectionArgs): Promise<Account> => {
+  const keyStore = new InMemoryKeyStore()
+  await keyStore.setKey(networkId, accountId, keypair)
+
+  const connection = Connection.fromConfig({
+    networkId,
+    provider: {
+      type: 'JsonRpcProvider',
+      args: {
+        url: {
+          testnet: 'https://rpc.testnet.near.org',
+          mainnet: 'https://rpc.mainnet.near.org',
+        }[networkId],
+      },
+    },
+    signer: { type: 'InMemorySigner', keyStore },
+  })
+
+  return new Account(connection, accountId)
+}

package/src/utils/chains/near/constants.ts

@@ -0,0 +1,4 @@
+import BN from 'bn.js'
+
+export const NEAR_MAX_GAS = new BN('300000000000000')
+export const DONT_CARE_ACCOUNT_ID = 'dontcare'

package/src/utils/chains/near/index.ts

@@ -0,0 +1,3 @@
+export * as transactionBuilder from './transactionBuilder'
+export * as signAndSend from './signAndSend'
+export * from './ChainSignatureContract'

package/src/utils/chains/near/signAndSend/index.ts

@@ -0,0 +1 @@
+export * as keypair from './keypair'

package/src/utils/chains/near/signAndSend/keypair.ts

@@ -0,0 +1,178 @@
+import { type KeyPair } from '@near-js/crypto'
+
+import { Bitcoin, Cosmos, EVM } from '@chains'
+import { BTCRpcAdapters } from '@chains/Bitcoin/BTCRpcAdapter'
+import { getNearAccount } from '@utils/chains/near/account'
+import { ChainSignatureContract } from '@utils/chains/near/ChainSignatureContract'
+import {
+  type Response,
+  type BitcoinRequest,
+  type CosmosRequest,
+  type EVMRequest,
+} from '@utils/chains/near/types'
+
+export const EVMTransaction = async (
+  req: EVMRequest,
+  keyPair: KeyPair
+): Promise<Response> => {
+  try {
+    const account = await getNearAccount({
+      networkId: req.nearAuthentication.networkId,
+      accountId: req.nearAuthentication.accountId,
+      keypair: keyPair,
+    })
+
+    const contract = new ChainSignatureContract({
+      networkId: req.nearAuthentication.networkId,
+      contractId: req.chainConfig.contract,
+      accountId: account.accountId,
+      keypair: keyPair,
+    })
+
+    const evm = new EVM({
+      rpcUrl: req.chainConfig.providerUrl,
+      contract,
+    })
+
+    const { transaction, hashesToSign } =
+      await evm.prepareTransactionForSigning(req.transaction)
+
+    const signature = await contract.sign({
+      payload: hashesToSign[0],
+      path: req.derivationPath,
+      key_version: 0,
+    })
+
+    const txSerialized = evm.attachTransactionSignature({
+      transaction,
+      rsvSignatures: [signature],
+    })
+
+    const txHash = await evm.broadcastTx(txSerialized)
+
+    return {
+      transactionHash: txHash,
+      success: true,
+    }
+  } catch (e: unknown) {
+    console.error(e)
+    return {
+      success: false,
+      errorMessage: e instanceof Error ? e.message : String(e),
+    }
+  }
+}
+
+export const BTCTransaction = async (
+  req: BitcoinRequest,
+  keyPair: KeyPair
+): Promise<Response> => {
+  try {
+    const account = await getNearAccount({
+      networkId: req.nearAuthentication.networkId,
+      accountId: req.nearAuthentication.accountId,
+      keypair: keyPair,
+    })
+
+    const contract = new ChainSignatureContract({
+      networkId: req.nearAuthentication.networkId,
+      contractId: req.chainConfig.contract,
+      accountId: account.accountId,
+      keypair: keyPair,
+    })
+
+    const btc = new Bitcoin({
+      btcRpcAdapter: new BTCRpcAdapters.Mempool(req.chainConfig.providerUrl),
+      contract,
+      network: req.chainConfig.network,
+    })
+
+    const { transaction, hashesToSign } =
+      await btc.prepareTransactionForSigning(req.transaction)
+
+    const signatures = await Promise.all(
+      hashesToSign.map(
+        async (payload) =>
+          await contract.sign({
+            payload,
+            path: req.derivationPath,
+            key_version: 0,
+          })
+      )
+    )
+
+    const txSerialized = btc.attachTransactionSignature({
+      transaction,
+      rsvSignatures: signatures,
+    })
+
+    const txHash = await btc.broadcastTx(txSerialized)
+
+    return {
+      transactionHash: txHash,
+      success: true,
+    }
+  } catch (e: unknown) {
+    return {
+      success: false,
+      errorMessage: e instanceof Error ? e.message : String(e),
+    }
+  }
+}
+
+export const CosmosTransaction = async (
+  req: CosmosRequest,
+  keyPair: KeyPair
+): Promise<Response> => {
+  try {
+    const account = await getNearAccount({
+      networkId: req.nearAuthentication.networkId,
+      accountId: req.nearAuthentication.accountId,
+      keypair: keyPair,
+    })
+
+    const contract = new ChainSignatureContract({
+      networkId: req.nearAuthentication.networkId,
+      contractId: req.chainConfig.contract,
+      accountId: account.accountId,
+      keypair: keyPair,
+    })
+
+    const cosmos = new Cosmos({
+      contract,
+      chainId: req.chainConfig.chainId,
+    })
+
+    const { transaction, hashesToSign } =
+      await cosmos.prepareTransactionForSigning(req.transaction)
+
+    const signatures = await Promise.all(
+      hashesToSign.map(
+        async (payload) =>
+          await contract.sign({
+            payload,
+            path: req.derivationPath,
+            key_version: 0,
+          })
+      )
+    )
+
+    const txSerialized = cosmos.attachTransactionSignature({
+      transaction,
+      rsvSignatures: signatures,
+    })
+
+    const txHash = await cosmos.broadcastTx(txSerialized)
+
+    return {
+      transactionHash: txHash,
+      success: true,
+    }
+  } catch (e: unknown) {
+    console.error(e)
+    return {
+      success: false,
+      errorMessage: e instanceof Error ? e.message : String(e),
+    }
+  }
+}

package/src/utils/chains/near/transactionBuilder.ts

@@ -0,0 +1,73 @@
+import type {
+  Action,
+  FinalExecutionOutcome,
+  NetworkId,
+} from '@near-wallet-selector/core'
+import BN from 'bn.js'
+import { getTransactionLastResult } from 'near-api-js/lib/providers'
+
+import {
+  type RSVSignature,
+  type KeyDerivationPath,
+  type MPCSignature,
+  type HashToSign,
+} from '@chains/types'
+import { cryptography } from '@utils'
+import { ChainSignatureContract } from '@utils/chains/near/ChainSignatureContract'
+import { NEAR_MAX_GAS } from '@utils/chains/near/constants'
+import { type ChainSignatureContractIds } from '@utils/chains/near/types'
+
+export const mpcPayloadsToChainSigTransaction = async ({
+  networkId,
+  contractId,
+  hashesToSign,
+  path,
+}: {
+  networkId: NetworkId
+  contractId: ChainSignatureContractIds
+  hashesToSign: HashToSign[]
+  path: KeyDerivationPath
+}): Promise<{
+  receiverId: string
+  actions: Action[]
+}> => {
+  const contract = new ChainSignatureContract({
+    networkId,
+    contractId,
+  })
+
+  const currentContractFee = await contract.getCurrentSignatureDeposit()
+
+  return {
+    receiverId: contractId,
+    actions: hashesToSign.map((payload) => ({
+      type: 'FunctionCall',
+      params: {
+        methodName: 'sign',
+        args: {
+          request: {
+            payload: Array.from(payload),
+            path,
+            key_version: 0,
+          },
+        },
+        gas: NEAR_MAX_GAS.div(new BN(hashesToSign.length)).toString(),
+        deposit: currentContractFee?.toString() || '1',
+      },
+    })),
+  }
+}
+
+export const responseToMpcSignature = ({
+  response,
+}: {
+  response: FinalExecutionOutcome
+}): RSVSignature | undefined => {
+  const signature: MPCSignature = getTransactionLastResult(response)
+
+  if (signature) {
+    return cryptography.toRSV(signature)
+  } else {
+    return undefined
+  }
+}

package/src/utils/chains/near/types.ts

@@ -0,0 +1,77 @@
+import type {
+  BTCTransactionRequest,
+  BTCNetworkIds,
+} from '@chains/Bitcoin/types'
+import type {
+  CosmosNetworkIds,
+  CosmosTransactionRequest,
+} from '@chains/Cosmos/types'
+import { type EVMTransactionRequest } from '@chains/EVM/types'
+import type { KeyDerivationPath } from '@chains/types'
+
+/** 
+Available ChainSignature contracts:
+  - Mainnet: v1.signer
+  - Testnet: v1.signer-prod.testnet
+  - Development (unstable): v1.signer-dev.testnet
+*/
+export type ChainSignatureContractIds = string
+
+export type NearNetworkIds = 'mainnet' | 'testnet'
+
+export interface ChainProvider {
+  providerUrl: string
+  contract: ChainSignatureContractIds
+}
+
+export interface NearAuthentication {
+  networkId: NearNetworkIds
+  accountId: string
+}
+
+interface SuccessResponse {
+  transactionHash: string
+  success: true
+}
+
+interface FailureResponse {
+  success: false
+  errorMessage: string
+}
+
+export type Response = SuccessResponse | FailureResponse
+
+export type EVMChainConfigWithProviders = ChainProvider
+
+export interface EVMRequest {
+  transaction: EVMTransactionRequest
+  chainConfig: EVMChainConfigWithProviders
+  nearAuthentication: NearAuthentication
+  fastAuthRelayerUrl?: string
+  derivationPath: KeyDerivationPath
+}
+
+export type BTCChainConfigWithProviders = ChainProvider & {
+  network: BTCNetworkIds
+}
+
+export interface BitcoinRequest {
+  transaction: BTCTransactionRequest
+  chainConfig: BTCChainConfigWithProviders
+  nearAuthentication: NearAuthentication
+  fastAuthRelayerUrl?: string
+  derivationPath: KeyDerivationPath
+}
+
+export interface CosmosChainConfig {
+  contract: ChainSignatureContractIds
+  chainId: CosmosNetworkIds
+}
+
+export interface CosmosRequest {
+  chainConfig: CosmosChainConfig
+  transaction: CosmosTransactionRequest
+  nearAuthentication: NearAuthentication
+  derivationPath: KeyDerivationPath
+  fastAuthRelayerUrl?: string
+}

package/src/utils/constants.ts

@@ -0,0 +1,62 @@
+import { type NajPublicKey } from '@chains'
+
+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',
+  },
+}