signet.js 0.0.1-beta.7 → 0.0.1-beta.8

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

@@ -1,195 +0,0 @@
-import { type Account, Contract } from '@near-js/accounts'
-import { KeyPair } from '@near-js/crypto'
-import { actionCreators } from '@near-js/transactions'
-import BN from 'bn.js'
-import { base_decode } from 'near-api-js/lib/utils/serialize'
-
-import { utils } from '@chains'
-import { ChainSignatureContract as AbstractChainSignatureContract } from '@chains/ChainSignatureContract'
-import type { SignArgs } from '@chains/ChainSignatureContract'
-import type {
-  RSVSignature,
-  MPCSignature,
-  UncompressedPubKeySEC1,
-} from '@chains/types'
-import { chains } from '@utils'
-import { getNearAccount } from '@utils/chains/near/account'
-import {
-  DONT_CARE_ACCOUNT_ID,
-  NEAR_MAX_GAS,
-} from '@utils/chains/near/constants'
-import { parseSignedDelegateForRelayer } from '@utils/chains/near/relayer'
-import {
-  type NearNetworkIds,
-  type ChainSignatureContractIds,
-} from '@utils/chains/near/types'
-
-const najToUncompressedPubKey = (najPubKey: string): UncompressedPubKeySEC1 => {
-  return `04${Buffer.from(base_decode(najPubKey.split(':')[1])).toString('hex')}`
-}
-
-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<string>
-  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<string>
-}
-
-interface ChainSignatureContractArgs {
-  networkId: NearNetworkIds
-  contractId: ChainSignatureContractIds
-  accountId?: string
-  keypair?: KeyPair
-}
-
-/**
- * This contract will default to view methods only.
- * If you want to use the change methods, you need to provide an account and keypair.
- */
-export class ChainSignatureContract extends AbstractChainSignatureContract {
-  private readonly networkId: NearNetworkIds
-  private readonly contractId: ChainSignatureContractIds
-  private readonly accountId: string
-  private readonly keypair: KeyPair
-
-  constructor({
-    networkId,
-    contractId,
-    accountId = DONT_CARE_ACCOUNT_ID,
-    keypair = KeyPair.fromRandom('ed25519'),
-  }: ChainSignatureContractArgs) {
-    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 najToUncompressedPubKey(najPubKey)
-  }
-
-  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 utils.toRSV(signature)
-  }
-
-  static async signWithRelayer({
-    account,
-    contract,
-    signArgs,
-    deposit,
-    relayerUrl,
-  }: {
-    account: Account
-    contract: ChainSignatureContractIds
-    signArgs: SignArgs
-    deposit: BN
-    relayerUrl: string
-  }): Promise<RSVSignature> {
-    const functionCall = actionCreators.functionCall(
-      'sign',
-      { request: signArgs },
-      BigInt(NEAR_MAX_GAS.toString()),
-      BigInt(deposit.toString())
-    )
-
-    const signedDelegate = await account.signedDelegate({
-      receiverId: contract,
-      actions: [functionCall],
-      blockHeightTtl: 60,
-    })
-
-    // Remove the cached access key to prevent nonce reuse
-    delete account.accessKeyByPublicKeyCache[
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-      signedDelegate.delegateAction.publicKey.toString()
-    ]
-
-    const res = await fetch(`${relayerUrl}/send_meta_tx_async`, {
-      method: 'POST',
-      mode: 'cors',
-      body: JSON.stringify(parseSignedDelegateForRelayer(signedDelegate)),
-      headers: new Headers({ 'Content-Type': 'application/json' }),
-    })
-
-    const txHash = await res.text()
-    const txStatus = await account.connection.provider.txStatus(
-      txHash,
-      account.accountId,
-      'FINAL'
-    )
-
-    const signature = chains.near.transactionBuilder.responseToMpcSignature({
-      response: txStatus,
-    })
-
-    if (!signature) {
-      throw new Error('Signature error, please retry')
-    }
-
-    return 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/relayer/index.ts

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

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

@@ -1,39 +0,0 @@
-import { type SignedDelegate } from '@near-js/transactions'
-import bs58 from 'bs58'
-
-import { type SignedDelegateRelayerFormat } from './types'
-
-/**
- * Parses the signedDelegate object from the Multi-Party Computation (MPC) format to the Relayer format.
- * @param signedDelegate - The signedDelegate object in MPC format.
- * @returns The signedDelegate object in Relayer format.
- */
-export function parseSignedDelegateForRelayer(
-  signedDelegate: SignedDelegate
-): SignedDelegateRelayerFormat {
-  return {
-    delegate_action: {
-      actions: signedDelegate.delegateAction.actions
-        .map((action) => {
-          if (action.functionCall) {
-            return {
-              FunctionCall: {
-                method_name: action.functionCall.methodName,
-                args: Buffer.from(action.functionCall.args).toString('base64'),
-                gas: Number(action.functionCall.gas),
-                deposit: action.functionCall.deposit.toString(),
-              },
-            }
-          }
-          return undefined
-        })
-        .flatMap((t) => (t ? [t] : [])),
-      nonce: Number(signedDelegate.delegateAction.nonce),
-      max_block_height: Number(signedDelegate.delegateAction.maxBlockHeight),
-      public_key: signedDelegate.delegateAction.publicKey.toString(),
-      receiver_id: signedDelegate.delegateAction.receiverId,
-      sender_id: signedDelegate.delegateAction.senderId,
-    },
-    signature: `ed25519:${bs58.encode(signedDelegate.signature.data)}`,
-  }
-}

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

@@ -1,24 +0,0 @@
-interface FunctionCallRelayer {
-  FunctionCall: {
-    method_name: string
-    args: string
-    gas: number
-    deposit: string
-  }
-}
-
-type ActionsRelayer = FunctionCallRelayer
-
-interface DelegateActionRelayerFormat {
-  actions: ActionsRelayer[]
-  nonce: number
-  max_block_height: number
-  public_key: string
-  receiver_id: string
-  sender_id: string
-}
-
-export interface SignedDelegateRelayerFormat {
-  delegate_action: DelegateActionRelayerFormat
-  signature: string
-}

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,180 +0,0 @@
-import { type KeyPair } from '@near-js/crypto'
-
-import { Bitcoin, Cosmos, EVM } from '@chains'
-import { BTCRpcAdapters } from '@chains/Bitcoin/BTCRpcAdapter'
-import { type Response } from '@chains/types'
-import { getNearAccount } from '@utils/chains/near/account'
-import { ChainSignatureContract } from '@utils/chains/near/ChainSignatureContract'
-import {
-  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, mpcPayloads } = await evm.getMPCPayloadAndTransaction(
-      req.transaction
-    )
-
-    const signature = await contract.sign({
-      payload: mpcPayloads[0].payload,
-      path: req.derivationPath,
-      key_version: 0,
-    })
-
-    const txSerialized = evm.addSignature({
-      transaction,
-      mpcSignatures: [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, mpcPayloads } = await btc.getMPCPayloadAndTransaction(
-      req.transaction
-    )
-
-    const signatures = await Promise.all(
-      mpcPayloads.map(
-        async ({ payload }) =>
-          await contract.sign({
-            payload,
-            path: req.derivationPath,
-            key_version: 0,
-          })
-      )
-    )
-
-    const txSerialized = btc.addSignature({
-      transaction,
-      mpcSignatures: 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, mpcPayloads } =
-      await cosmos.getMPCPayloadAndTransaction(req.transaction)
-
-    const signatures = await Promise.all(
-      mpcPayloads.map(
-        async ({ payload }) =>
-          await contract.sign({
-            payload,
-            path: req.derivationPath,
-            key_version: 0,
-          })
-      )
-    )
-
-    const txSerialized = cosmos.addSignature({
-      transaction,
-      mpcSignatures: 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,138 +0,0 @@
-import type {
-  Action,
-  FinalExecutionOutcome,
-  NetworkId,
-} from '@near-wallet-selector/core'
-import BN from 'bn.js'
-import { type ExecutionOutcomeWithId } from 'near-api-js/lib/providers'
-
-import { utils } from '@chains'
-import {
-  type RSVSignature,
-  type KeyDerivationPath,
-  type MPCSignature,
-  type MPCPayloads,
-} from '@chains/types'
-import { ChainSignatureContract } from '@utils/chains/near/ChainSignatureContract'
-import { NEAR_MAX_GAS } from '@utils/chains/near/constants'
-import {
-  type NFTKeysContracts,
-  type ChainSignatureContractIds,
-} from '@utils/chains/near/types'
-
-export const mpcPayloadsToChainSigTransaction = async ({
-  networkId,
-  contractId,
-  mpcPayloads,
-  path,
-}: {
-  networkId: NetworkId
-  contractId: ChainSignatureContractIds
-  mpcPayloads: MPCPayloads
-  path: KeyDerivationPath
-}): Promise<{
-  receiverId: string
-  actions: Action[]
-}> => {
-  const contract = new ChainSignatureContract({
-    networkId,
-    contractId,
-  })
-
-  const currentContractFee = await contract.getCurrentSignatureDeposit()
-
-  return {
-    receiverId: contractId,
-    actions: mpcPayloads.map(({ payload }) => ({
-      type: 'FunctionCall',
-      params: {
-        methodName: 'sign',
-        args: {
-          request: {
-            payload: Array.from(payload),
-            path,
-            key_version: 0,
-          },
-        },
-        gas: NEAR_MAX_GAS.div(new BN(mpcPayloads.length)).toString(),
-        deposit: currentContractFee?.toString() || '1',
-      },
-    })),
-  }
-}
-
-export const mpcPayloadsToNFTKeysTransaction = async ({
-  networkId,
-  chainSigContract,
-  nftKeysContract,
-  mpcPayloads,
-  path,
-  tokenId,
-}: {
-  networkId: NetworkId
-  chainSigContract: ChainSignatureContractIds
-  nftKeysContract: NFTKeysContracts
-  mpcPayloads: MPCPayloads
-  path: KeyDerivationPath
-  tokenId: string
-}): Promise<{
-  receiverId: string
-  actions: Action[]
-}> => {
-  const contract = new ChainSignatureContract({
-    networkId,
-    contractId: chainSigContract,
-  })
-
-  const currentContractFee = await contract.getCurrentSignatureDeposit()
-
-  return {
-    receiverId: nftKeysContract,
-    actions: mpcPayloads.map(({ payload }) => ({
-      type: 'FunctionCall',
-      params: {
-        methodName: 'ckt_sign_hash',
-        args: {
-          token_id: tokenId,
-          path,
-          payload: Array.from(payload),
-        },
-        gas: NEAR_MAX_GAS.div(new BN(mpcPayloads.length)).toString(),
-        deposit: currentContractFee?.toString() || '1',
-      },
-    })),
-  }
-}
-
-export const responseToMpcSignature = ({
-  response,
-}: {
-  response: FinalExecutionOutcome
-}): RSVSignature | undefined => {
-  const signature: string = response.receipts_outcome.reduce<string>(
-    (acc: string, curr: ExecutionOutcomeWithId) => {
-      if (acc) {
-        return acc
-      }
-      const { status } = curr.outcome
-      return (
-        (typeof status === 'object' &&
-          status.SuccessValue &&
-          status.SuccessValue !== '' &&
-          Buffer.from(status.SuccessValue, 'base64').toString('utf-8')) ||
-        ''
-      )
-    },
-    ''
-  )
-
-  if (signature) {
-    const parsedJSONSignature = JSON.parse(signature) as {
-      Ok: MPCSignature
-    }
-
-    return utils.toRSV(parsedJSONSignature.Ok)
-  } else {
-    return undefined
-  }
-}

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

@@ -1,67 +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 NFTKeysContracts = string
-
-export type NearNetworkIds = 'mainnet' | 'testnet'
-
-export interface ChainProvider {
-  providerUrl: string
-  contract: ChainSignatureContractIds
-}
-
-export interface NearAuthentication {
-  networkId: NearNetworkIds
-  accountId: string
-}
-
-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/index.ts

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