Implementing a Custom Chain Signature Contract

import { contracts, chainAdapters } from 'signet.js'
 
const contract = new contracts.near.ChainSignatureContract({
  networkId: 'testnet',
  contractId: 'v1.signer-prod.testnet',
  accountId,
  keypair,
})

import type BN from 'bn.js'
 
import type { RSVSignature, UncompressedPubKeySEC1 } from '@types'
 
export interface SignArgs {
  /** The payload to sign as an array of 32 bytes */
  payload: number[]
  /** The derivation path for key generation */
  path: string
  /** Version of the key to use */
  key_version: number
}
 
/**
 * Base contract interface required for compatibility with ChainAdapter instances like EVM and Bitcoin.
 *
 * See {@link EVM} and {@link Bitcoin} for example implementations.
 */
export abstract class BaseChainSignatureContract {
  /**
   * Gets the current signature deposit required by the contract.
   * This deposit amount helps manage network congestion.
   *
   * @returns Promise resolving to the required deposit amount as a BigNumber
   */
  abstract getCurrentSignatureDeposit(): Promise<BN>
 
  /**
   * Derives a child public key using a\ derivation path and predecessor.
   *
   * @param args - Arguments for key derivation
   * @param args.path - The string path to use derive the key
   * @param args.predecessor - The id/address of the account requesting signature
   * @returns Promise resolving to the derived SEC1 uncompressed public key
   */
  abstract getDerivedPublicKey(
    args: {
      path: string
      predecessor: string
    } & Record<string, unknown>
  ): Promise<UncompressedPubKeySEC1>
}
 
/**
 * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
 */
export abstract class ChainSignatureContract extends BaseChainSignatureContract {
  /**
   * Signs a payload using Sig Network MPC.
   *
   * @param args - Arguments for the signing operation
   * @param args.payload - The data to sign as an array of 32 bytes
   * @param args.path - The string path to use derive the key
   * @param args.key_version - Version of the key to use
   * @returns Promise resolving to the RSV signature
   */
  abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>
 
  /**
   * Gets the public key associated with this contract instance.
   *
   * @returns Promise resolving to the SEC1 uncompressed public key
   */
  abstract getPublicKey(): Promise<UncompressedPubKeySEC1>
}

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.'
      )
    }
  }
}