signet.js 0.0.7 → 0.0.9-retry

package/src/contracts/evm/ChainSignaturesContractABI.ts

@@ -1,359 +0,0 @@
-export const abi = [
-  {
-    inputs: [
-      { internalType: 'address', name: '_mpc_network', type: 'address' },
-      { internalType: 'uint256', name: '_signatureDeposit', type: 'uint256' },
-    ],
-    stateMutability: 'nonpayable',
-    type: 'constructor',
-  },
-  { inputs: [], name: 'AccessControlBadConfirmation', type: 'error' },
-  {
-    inputs: [
-      { internalType: 'address', name: 'account', type: 'address' },
-      { internalType: 'bytes32', name: 'neededRole', type: 'bytes32' },
-    ],
-    name: 'AccessControlUnauthorizedAccount',
-    type: 'error',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      {
-        indexed: true,
-        internalType: 'bytes32',
-        name: 'previousAdminRole',
-        type: 'bytes32',
-      },
-      {
-        indexed: true,
-        internalType: 'bytes32',
-        name: 'newAdminRole',
-        type: 'bytes32',
-      },
-    ],
-    name: 'RoleAdminChanged',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      {
-        indexed: true,
-        internalType: 'address',
-        name: 'account',
-        type: 'address',
-      },
-      {
-        indexed: true,
-        internalType: 'address',
-        name: 'sender',
-        type: 'address',
-      },
-    ],
-    name: 'RoleGranted',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      {
-        indexed: true,
-        internalType: 'address',
-        name: 'account',
-        type: 'address',
-      },
-      {
-        indexed: true,
-        internalType: 'address',
-        name: 'sender',
-        type: 'address',
-      },
-    ],
-    name: 'RoleRevoked',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: 'bytes32',
-        name: 'requestId',
-        type: 'bytes32',
-      },
-      {
-        indexed: false,
-        internalType: 'address',
-        name: 'responder',
-        type: 'address',
-      },
-      { indexed: false, internalType: 'string', name: 'error', type: 'string' },
-    ],
-    name: 'SignatureError',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: false,
-        internalType: 'address',
-        name: 'sender',
-        type: 'address',
-      },
-      {
-        indexed: false,
-        internalType: 'bytes32',
-        name: 'payload',
-        type: 'bytes32',
-      },
-      {
-        indexed: false,
-        internalType: 'uint32',
-        name: 'keyVersion',
-        type: 'uint32',
-      },
-      {
-        indexed: false,
-        internalType: 'uint256',
-        name: 'deposit',
-        type: 'uint256',
-      },
-      {
-        indexed: false,
-        internalType: 'uint256',
-        name: 'chainId',
-        type: 'uint256',
-      },
-      { indexed: false, internalType: 'string', name: 'path', type: 'string' },
-      { indexed: false, internalType: 'string', name: 'algo', type: 'string' },
-      { indexed: false, internalType: 'string', name: 'dest', type: 'string' },
-      {
-        indexed: false,
-        internalType: 'string',
-        name: 'params',
-        type: 'string',
-      },
-    ],
-    name: 'SignatureRequested',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: 'bytes32',
-        name: 'requestId',
-        type: 'bytes32',
-      },
-      {
-        indexed: false,
-        internalType: 'address',
-        name: 'responder',
-        type: 'address',
-      },
-      {
-        components: [
-          {
-            components: [
-              { internalType: 'uint256', name: 'x', type: 'uint256' },
-              { internalType: 'uint256', name: 'y', type: 'uint256' },
-            ],
-            internalType: 'struct ChainSignatures.AffinePoint',
-            name: 'bigR',
-            type: 'tuple',
-          },
-          { internalType: 'uint256', name: 's', type: 'uint256' },
-          { internalType: 'uint8', name: 'recoveryId', type: 'uint8' },
-        ],
-        indexed: false,
-        internalType: 'struct ChainSignatures.Signature',
-        name: 'signature',
-        type: 'tuple',
-      },
-    ],
-    name: 'SignatureResponded',
-    type: 'event',
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: 'address',
-        name: 'owner',
-        type: 'address',
-      },
-      {
-        indexed: false,
-        internalType: 'uint256',
-        name: 'amount',
-        type: 'uint256',
-      },
-    ],
-    name: 'Withdraw',
-    type: 'event',
-  },
-  {
-    inputs: [],
-    name: 'DEFAULT_ADMIN_ROLE',
-    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [{ internalType: 'bytes32', name: 'role', type: 'bytes32' }],
-    name: 'getRoleAdmin',
-    outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [],
-    name: 'getSignatureDeposit',
-    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [
-      { internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      { internalType: 'address', name: 'account', type: 'address' },
-    ],
-    name: 'grantRole',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [
-      { internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      { internalType: 'address', name: 'account', type: 'address' },
-    ],
-    name: 'hasRole',
-    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [
-      { internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      { internalType: 'address', name: 'callerConfirmation', type: 'address' },
-    ],
-    name: 'renounceRole',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: 'bytes32', name: 'requestId', type: 'bytes32' },
-          {
-            components: [
-              {
-                components: [
-                  { internalType: 'uint256', name: 'x', type: 'uint256' },
-                  { internalType: 'uint256', name: 'y', type: 'uint256' },
-                ],
-                internalType: 'struct ChainSignatures.AffinePoint',
-                name: 'bigR',
-                type: 'tuple',
-              },
-              { internalType: 'uint256', name: 's', type: 'uint256' },
-              { internalType: 'uint8', name: 'recoveryId', type: 'uint8' },
-            ],
-            internalType: 'struct ChainSignatures.Signature',
-            name: 'signature',
-            type: 'tuple',
-          },
-        ],
-        internalType: 'struct ChainSignatures.Response[]',
-        name: '_responses',
-        type: 'tuple[]',
-      },
-    ],
-    name: 'respond',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: 'bytes32', name: 'requestId', type: 'bytes32' },
-          { internalType: 'string', name: 'errorMessage', type: 'string' },
-        ],
-        internalType: 'struct ChainSignatures.ErrorResponse[]',
-        name: '_errors',
-        type: 'tuple[]',
-      },
-    ],
-    name: 'respondError',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [
-      { internalType: 'bytes32', name: 'role', type: 'bytes32' },
-      { internalType: 'address', name: 'account', type: 'address' },
-    ],
-    name: 'revokeRole',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [{ internalType: 'uint256', name: '_amount', type: 'uint256' }],
-    name: 'setSignatureDeposit',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: 'bytes32', name: 'payload', type: 'bytes32' },
-          { internalType: 'string', name: 'path', type: 'string' },
-          { internalType: 'uint32', name: 'keyVersion', type: 'uint32' },
-          { internalType: 'string', name: 'algo', type: 'string' },
-          { internalType: 'string', name: 'dest', type: 'string' },
-          { internalType: 'string', name: 'params', type: 'string' },
-        ],
-        internalType: 'struct ChainSignatures.SignRequest',
-        name: '_request',
-        type: 'tuple',
-      },
-    ],
-    name: 'sign',
-    outputs: [],
-    stateMutability: 'payable',
-    type: 'function',
-  },
-  {
-    inputs: [{ internalType: 'bytes4', name: 'interfaceId', type: 'bytes4' }],
-    name: 'supportsInterface',
-    outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [
-      { internalType: 'uint256', name: '_amount', type: 'uint256' },
-      { internalType: 'address', name: '_receiver', type: 'address' },
-    ],
-    name: 'withdraw',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-]

package/src/contracts/evm/errors.ts

@@ -1,52 +0,0 @@
-import type { TransactionReceipt } from 'viem'
-
-export class ChainSignatureError extends Error {
-  requestId: `0x${string}`
-  receipt: TransactionReceipt
-
-  constructor(
-    message: string,
-    requestId: `0x${string}`,
-    receipt: TransactionReceipt
-  ) {
-    super(message)
-    this.name = 'ChainSignatureError'
-    this.requestId = requestId
-    this.receipt = receipt
-  }
-}
-
-export class SignatureNotFoundError extends ChainSignatureError {
-  constructor(requestId: `0x${string}`, receipt: TransactionReceipt) {
-    super('Signature not found after maximum retries', requestId, receipt)
-    this.name = 'SignatureNotFoundError'
-  }
-}
-
-export class SignatureContractError extends ChainSignatureError {
-  errorCode: string
-
-  constructor(
-    errorCode: string,
-    requestId: `0x${string}`,
-    receipt: TransactionReceipt
-  ) {
-    super(`Signature error: ${errorCode}`, requestId, receipt)
-    this.name = 'SignatureContractError'
-    this.errorCode = errorCode
-  }
-}
-
-export class SigningError extends ChainSignatureError {
-  originalError?: Error
-
-  constructor(
-    requestId: `0x${string}`,
-    receipt: TransactionReceipt,
-    originalError?: Error
-  ) {
-    super('Error signing request', requestId, receipt)
-    this.name = 'SigningError'
-    this.originalError = originalError
-  }
-}

package/src/contracts/evm/index.ts

@@ -1,10 +0,0 @@
-import * as ChainSignaturesContractABI from './ChainSignaturesContractABI'
-import * as errors from './errors'
-export * from './ChainSignaturesContract'
-
-const utils = {
-  ChainSignaturesContractABI,
-  errors,
-}
-
-export { utils }

package/src/contracts/evm/types.ts

@@ -1,39 +0,0 @@
-import type { Address, 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
-}
-
-export interface RequestIdArgs {
-  address: Address
-  payload: Hex
-  path: string
-  keyVersion: number
-  chainId: bigint
-  algo: string
-  dest: string
-  params: string
-}

package/src/contracts/evm/utils.ts

@@ -1,41 +0,0 @@
-import { encodeAbiParameters, keccak256 } from 'viem'
-import * as chains from 'viem/chains'
-import type { Chain } from 'viem/chains'
-
-import { type RequestIdArgs } from './types'
-
-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')
-}
-
-export const getRequestId = (request: RequestIdArgs): `0x${string}` => {
-  const encoded = encodeAbiParameters(
-    [
-      { type: 'address' },
-      { type: 'bytes' },
-      { type: 'string' },
-      { type: 'uint32' },
-      { type: 'uint256' },
-      { type: 'string' },
-      { type: 'string' },
-      { type: 'string' },
-    ],
-    [
-      request.address,
-      request.payload,
-      request.path,
-      Number(request.keyVersion),
-      request.chainId,
-      request.algo,
-      request.dest,
-      request.params,
-    ]
-  )
-
-  return keccak256(encoded)
-}

package/src/contracts/index.ts

@@ -1,4 +0,0 @@
-export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract'
-
-export * as near from './near'
-export * as evm from './evm'

package/src/contracts/near/ChainSignatureContract.ts

@@ -1,196 +0,0 @@
-import { Contract } from '@near-js/accounts'
-import { KeyPair } from '@near-js/crypto'
-import { actionCreators } from '@near-js/transactions'
-import { najToUncompressedPubKeySEC1 } from '@utils/cryptography'
-import { getRootPublicKey } from '@utils/publicKey'
-import BN from 'bn.js'
-
-import { CHAINS, KDF_CHAIN_IDS } from '@constants'
-import { ChainSignatureContract as AbstractChainSignatureContract } from '@contracts/ChainSignatureContract'
-import type { SignArgs } from '@contracts/ChainSignatureContract'
-import { getNearAccount } from '@contracts/near/account'
-import { DONT_CARE_ACCOUNT_ID, NEAR_MAX_GAS } from '@contracts/near/constants'
-import {
-  responseToMpcSignature,
-  type SendTransactionOptions,
-  sendTransactionUntil,
-} from '@contracts/near/transaction'
-import {
-  type NearNetworkIds,
-  type ChainSignatureContractIds,
-} from '@contracts/near/types'
-import type { RSVSignature, UncompressedPubKeySEC1, NajPublicKey } from '@types'
-import { cryptography } from '@utils'
-
-type NearContract = Contract & {
-  public_key: () => Promise<NajPublicKey>
-  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
-  rootPublicKey?: NajPublicKey
-  sendTransactionOptions?: SendTransactionOptions
-}
-
-/**
- * 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
-  private readonly rootPublicKey?: NajPublicKey
-  private readonly sendTransactionOptions?: SendTransactionOptions
-  /**
-   * 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.
-   * @param args.rootPublicKey - Optional root public key for the contract. If not provided, it will be derived from the contract ID.
-   * @param args.sendTransactionOptions - Optional configuration for transaction sending behavior.
-   */
-  constructor({
-    networkId,
-    contractId,
-    accountId = DONT_CARE_ACCOUNT_ID,
-    keypair = KeyPair.fromRandom('ed25519'),
-    rootPublicKey,
-    sendTransactionOptions,
-  }: ChainSignatureContractArgs) {
-    super()
-
-    this.networkId = networkId
-    this.contractId = contractId
-    this.accountId = accountId
-    this.keypair = keypair
-    this.sendTransactionOptions = sendTransactionOptions
-
-    this.rootPublicKey =
-      rootPublicKey || getRootPublicKey(this.contractId, CHAINS.NEAR)
-  }
-
-  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',
-      ],
-      // Change methods use the sendTransactionUntil because the internal retry of the Contract class
-      // throws on NodeJs.
-      changeMethods: [],
-      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> {
-    if (this.rootPublicKey) {
-      const pubKey = cryptography.deriveChildPublicKey(
-        await this.getPublicKey(),
-        args.predecessor.toLowerCase(),
-        args.path,
-        KDF_CHAIN_IDS.NEAR
-      )
-      return pubKey
-    } else {
-      // Support for legacy contract
-      const contract = await this.getContract()
-      const najPubKey = await contract.derived_public_key(args)
-      return najToUncompressedPubKeySEC1(najPubKey)
-    }
-  }
-
-  async getPublicKey(): Promise<UncompressedPubKeySEC1> {
-    if (this.rootPublicKey) {
-      return najToUncompressedPubKeySEC1(this.rootPublicKey)
-    } else {
-      // Support for legacy contract
-      const contract = await this.getContract()
-      const najPubKey = await contract.public_key()
-      return najToUncompressedPubKeySEC1(najPubKey)
-    }
-  }
-
-  async sign(
-    args: SignArgs,
-    options?: {
-      nonce?: number
-    }
-  ): Promise<RSVSignature> {
-    this.requireAccount()
-
-    const deposit = await this.getCurrentSignatureDeposit()
-
-    const result = await sendTransactionUntil({
-      accountId: this.accountId,
-      keypair: this.keypair,
-      networkId: this.networkId,
-      receiverId: this.contractId,
-      actions: [
-        actionCreators.functionCall(
-          'sign',
-          { request: args },
-          BigInt(NEAR_MAX_GAS.toString()),
-          BigInt(deposit.toString())
-        ),
-      ],
-      nonce: options?.nonce,
-      options: this.sendTransactionOptions,
-    })
-
-    const signature = responseToMpcSignature({ response: result })
-
-    if (!signature) {
-      throw new Error('Transaction failed')
-    }
-
-    return signature
-  }
-
-  private requireAccount(): void {
-    if (this.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.'
-      )
-    }
-  }
-}