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

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

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

@@ -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/relayer/index.ts

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

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

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

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

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

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

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

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

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

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