signet.js 0.0.6 → 0.0.7

package/src/contracts/evm/ChainSignaturesContractABI.ts

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

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

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

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

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

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

package/src/contracts/near/ChainSignatureContract.ts

@@ -0,0 +1,196 @@
+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.'
+      )
+    }
+  }
+}