signet.js 0.0.3 → 0.0.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,62 +0,0 @@
-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',
-  },
-}