signet.js 0.0.7 → 0.0.9

package/src/contracts/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 '@contracts/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/contracts/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/contracts/near/index.ts

@@ -1,10 +0,0 @@
-import * as signAndSend from './signAndSend'
-import * as transaction from './transaction'
-export * from './ChainSignatureContract'
-
-const utils = {
-  transaction,
-  signAndSend,
-}
-
-export { utils }

package/src/contracts/near/signAndSend/index.ts

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

package/src/contracts/near/signAndSend/keypair.ts

@@ -1,178 +0,0 @@
-import { type KeyPair } from '@near-js/crypto'
-
-import * as chainAdapters from '@chain-adapters'
-import { BTCRpcAdapters } from '@chain-adapters/Bitcoin/BTCRpcAdapter'
-import { getNearAccount } from '@contracts/near/account'
-import { ChainSignatureContract } from '@contracts/near/ChainSignatureContract'
-import {
-  type Response,
-  type BitcoinRequest,
-  type CosmosRequest,
-  type EVMRequest,
-} from '@contracts/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 chainAdapters.evm.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.finalizeTransactionSigning({
-      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 chainAdapters.btc.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.finalizeTransactionSigning({
-      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 chainAdapters.cosmos.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.finalizeTransactionSigning({
-      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/contracts/near/transaction.ts

@@ -1,202 +0,0 @@
-import { InMemoryKeyStore } from '@near-js/keystores'
-import type { Action as TransactionAction } from '@near-js/transactions'
-import type { TxExecutionStatus } from '@near-js/types'
-import type {
-  Action as WalletAction,
-  FinalExecutionOutcome,
-  NetworkId,
-} from '@near-wallet-selector/core'
-import BN from 'bn.js'
-import {
-  transactions,
-  utils as nearUtils,
-  connect,
-  type KeyPair,
-} from 'near-api-js'
-import { getTransactionLastResult } from 'near-api-js/lib/providers'
-import { withRetry } from 'viem'
-
-import { ChainSignatureContract } from '@contracts/near/ChainSignatureContract'
-import { NEAR_MAX_GAS } from '@contracts/near/constants'
-import { type ChainSignatureContractIds } from '@contracts/near/types'
-import {
-  type RSVSignature,
-  type KeyDerivationPath,
-  type MPCSignature,
-  type HashToSign,
-} from '@types'
-import { cryptography } from '@utils'
-
-export const mpcPayloadsToChainSigTransaction = async ({
-  networkId,
-  contractId,
-  hashesToSign,
-  path,
-}: {
-  networkId: NetworkId
-  contractId: ChainSignatureContractIds
-  hashesToSign: HashToSign[]
-  path: KeyDerivationPath
-}): Promise<{
-  receiverId: string
-  actions: WalletAction[]
-}> => {
-  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 = getTransactionLastResult(response) as MPCSignature
-
-  if (signature) {
-    return cryptography.toRSV(signature)
-  } else {
-    return undefined
-  }
-}
-
-export interface SendTransactionOptions {
-  until: TxExecutionStatus
-  retryCount: number
-  delay: number
-  nodeUrl: string
-}
-
-export const sendTransactionUntil = async ({
-  accountId,
-  keypair,
-  networkId,
-  receiverId,
-  actions,
-  nonce,
-  options = {
-    until: 'EXECUTED_OPTIMISTIC',
-    retryCount: 3,
-    delay: 5000, // Near RPC timeout
-    nodeUrl:
-      networkId === 'testnet'
-        ? 'https://test.rpc.fastnear.com'
-        : 'https://free.rpc.fastnear.com',
-  },
-}: {
-  accountId: string
-  keypair: KeyPair
-  networkId: NetworkId
-  receiverId: string
-  actions: TransactionAction[]
-  nonce?: number
-  options?: SendTransactionOptions
-}): Promise<FinalExecutionOutcome> => {
-  const keyStore = new InMemoryKeyStore()
-  await keyStore.setKey(networkId, accountId, keypair)
-
-  const near = await connect({
-    networkId,
-    keyStore,
-    nodeUrl: options.nodeUrl,
-  })
-
-  const { signer } = near.connection
-  const publicKey = await signer.getPublicKey(
-    accountId,
-    near.connection.networkId
-  )
-
-  const accessKey = (await near.connection.provider.query(
-    `access_key/${accountId}/${publicKey.toString()}`,
-    ''
-  )) as unknown as {
-    block_hash: string
-    block_height: number
-    nonce: number
-    permission: string
-  }
-
-  const recentBlockHash = nearUtils.serialize.base_decode(accessKey.block_hash)
-
-  const tx = transactions.createTransaction(
-    accountId,
-    publicKey,
-    receiverId,
-    nonce ?? ++accessKey.nonce,
-    actions,
-    recentBlockHash
-  )
-
-  const serializedTx = nearUtils.serialize.serialize(
-    transactions.SCHEMA.Transaction,
-    tx
-  )
-
-  const nearTransactionSignature = await signer.signMessage(
-    serializedTx,
-    accountId,
-    near.connection.networkId
-  )
-
-  const signedTransaction = new transactions.SignedTransaction({
-    transaction: tx,
-    signature: new transactions.Signature({
-      keyType: tx.publicKey.keyType,
-      data: nearTransactionSignature.signature,
-    }),
-  })
-
-  const { transaction } = await near.connection.provider.sendTransactionUntil(
-    signedTransaction,
-    'INCLUDED_FINAL'
-  )
-
-  const txHash = transaction.hash as string | undefined
-
-  if (!txHash) {
-    throw new Error('No transaction hash found')
-  }
-
-  return await withRetry(
-    async () => {
-      const txOutcome = await near.connection.provider.txStatus(
-        txHash,
-        accountId,
-        options.until
-      )
-
-      if (txOutcome) {
-        return txOutcome
-      }
-
-      throw new Error('Transaction not found')
-    },
-    {
-      retryCount: options.retryCount,
-      delay: options.delay,
-    }
-  )
-}

package/src/contracts/near/types.ts

@@ -1,71 +0,0 @@
-import type {
-  BTCTransactionRequest,
-  BTCNetworkIds,
-} from '@chain-adapters/Bitcoin/types'
-import type {
-  CosmosNetworkIds,
-  CosmosTransactionRequest,
-} from '@chain-adapters/Cosmos/types'
-import { type EVMTransactionRequest } from '@chain-adapters/EVM/types'
-import type { KeyDerivationPath } from '@types'
-
-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/index.ts

@@ -1,5 +0,0 @@
-export * as constants from './constants'
-export * as utils from './utils'
-export * as chainAdapters from './chain-adapters'
-export * as contracts from './contracts'
-export * from './types'

package/src/types.ts

@@ -1,46 +0,0 @@
-import { type SignArgs } from '@contracts/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/utils/cryptography.ts

@@ -1,141 +0,0 @@
-import { base58 } from '@scure/base'
-import { ec as EC } from 'elliptic'
-import { sha3_256 } from 'js-sha3'
-import { keccak256 } from 'viem'
-
-import { KDF_CHAIN_IDS } from '@constants'
-import {
-  type NajPublicKey,
-  type MPCSignature,
-  type RSVSignature,
-  type UncompressedPubKeySEC1,
-} from '@types'
-
-export const toRSV = (signature: MPCSignature): RSVSignature => {
-  // Handle NearNearMpcSignature
-  if (
-    'big_r' in signature &&
-    typeof signature.big_r === 'object' &&
-    'affine_point' in signature.big_r &&
-    's' in signature &&
-    typeof signature.s === 'object' &&
-    'scalar' in signature.s
-  ) {
-    return {
-      r: signature.big_r.affine_point.substring(2),
-      s: signature.s.scalar,
-      v: signature.recovery_id + 27,
-    }
-  }
-  // Handle SigNetNearMpcSignature
-  else if (
-    'big_r' in signature &&
-    typeof signature.big_r === 'string' &&
-    's' in signature &&
-    typeof signature.s === 'string'
-  ) {
-    return {
-      r: signature.big_r.substring(2),
-      s: signature.s,
-      v: signature.recovery_id + 27,
-    }
-  }
-  // Handle SigNetEvmMpcSignature
-  else if (
-    'bigR' in signature &&
-    'x' in signature.bigR &&
-    's' in signature &&
-    typeof signature.s === 'bigint'
-  ) {
-    return {
-      r: signature.bigR.x.toString(16).padStart(64, '0'),
-      s: signature.s.toString(16).padStart(64, '0'),
-      v: signature.recoveryId + 27,
-    }
-  }
-
-  throw new Error('Invalid signature format')
-}
-
-/**
- * Compresses an uncompressed public key to its compressed format following SEC1 standards.
- * In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
- * The prefix indicates whether the y-coordinate is even (02) or odd (03).
- *
- * @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
- * @returns The compressed public key in hex format
- * @throws Error if the uncompressed public key length is invalid
- */
-export const compressPubKey = (
-  uncompressedPubKeySEC1: UncompressedPubKeySEC1
-): string => {
-  const slicedPubKey = uncompressedPubKeySEC1.slice(2)
-
-  if (slicedPubKey.length !== 128) {
-    throw new Error('Invalid uncompressed public key length')
-  }
-
-  const x = slicedPubKey.slice(0, 64)
-  const y = slicedPubKey.slice(64)
-
-  const isEven = parseInt(y.slice(-1), 16) % 2 === 0
-  const prefix = isEven ? '02' : '03'
-
-  return prefix + x
-}
-
-/**
- * Converts a NAJ public key to an uncompressed SEC1 public key.
- *
- * @param najPublicKey - The NAJ public key to convert (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
- * @returns The uncompressed SEC1 public key (e.g. 04 || x || y)
- */
-export const najToUncompressedPubKeySEC1 = (
-  najPublicKey: NajPublicKey
-): UncompressedPubKeySEC1 => {
-  const decodedKey = base58.decode(najPublicKey.split(':')[1])
-  return `04${Buffer.from(decodedKey).toString('hex')}`
-}
-
-/**
- * Derives a child public key from a parent public key using the sig.network v1.0.0 epsilon derivation scheme.
- * The parent public keys are defined in @constants.ts
- *
- * @param najPublicKey - The parent public key in uncompressed SEC1 format (e.g. 04 || x || y)
- * @param predecessorId - The predecessor ID is the address of the account calling the signer contract (e.g EOA or Contract Address)
- * @param path - Optional derivation path suffix (defaults to empty string)
- * @returns The derived child public key in uncompressed SEC1 format (04 || x || y)
- */
-export function deriveChildPublicKey(
-  rootUncompressedPubKeySEC1: UncompressedPubKeySEC1,
-  predecessorId: string,
-  path: string = '',
-  chainId: string
-): UncompressedPubKeySEC1 {
-  const ec = new EC('secp256k1')
-
-  const EPSILON_DERIVATION_PREFIX = 'sig.network v1.0.0 epsilon derivation'
-  const derivationPath = `${EPSILON_DERIVATION_PREFIX},${chainId},${predecessorId},${path}`
-
-  let scalarHex = ''
-
-  if (chainId === KDF_CHAIN_IDS.ETHEREUM) {
-    scalarHex = keccak256(Buffer.from(derivationPath)).slice(2)
-  } else if (chainId === KDF_CHAIN_IDS.NEAR) {
-    scalarHex = sha3_256(derivationPath)
-  } else {
-    throw new Error('Invalid chain ID')
-  }
-
-  const x = rootUncompressedPubKeySEC1.substring(2, 66)
-  const y = rootUncompressedPubKeySEC1.substring(66)
-
-  const oldPublicKeyPoint = ec.curve.point(x, y)
-  const scalarTimesG = ec.g.mul(scalarHex)
-  const newPublicKeyPoint = oldPublicKeyPoint.add(scalarTimesG)
-
-  const newX = newPublicKeyPoint.getX().toString('hex').padStart(64, '0')
-  const newY = newPublicKeyPoint.getY().toString('hex').padStart(64, '0')
-
-  return `04${newX}${newY}`
-}

package/src/utils/index.ts

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