@4mica/sdk 0.5.0 → 0.5.2

package/src/client.ts

@@ -1,347 +0,0 @@
-import { signatureToWords } from './bls';
-import { AuthSession } from './auth';
-import type { AuthTokens } from './auth';
-import { Config } from './config';
-import { ContractGateway } from './contract';
-import { AuthMissingConfigError, ClientInitializationError, VerificationError } from './errors';
-import { decodeGuaranteeClaims } from './guarantee';
-import {
-  AssetBalanceInfo,
-  BLSCert,
-  CollateralEventInfo,
-  GuaranteeInfo,
-  PaymentGuaranteeClaims,
-  PaymentGuaranteeRequestClaims,
-  PaymentSignature,
-  PendingRemunerationInfo,
-  RecipientPaymentInfo,
-  SigningScheme,
-  TabInfo,
-  TabPaymentStatus,
-  UserInfo,
-} from './models';
-import { RpcProxy } from './rpc';
-import { CorePublicParameters, PaymentSigner } from './signing';
-import { normalizeAddress, parseU256, serializeU256 } from './utils';
-
-const isNumericLike = (value: unknown): value is number | bigint | string =>
-  typeof value === 'number' || typeof value === 'bigint' || typeof value === 'string';
-
-type RpcTabStatus = {
-  paid?: number | bigint | string;
-  paidAmount?: number | bigint | string;
-  remunerated?: boolean;
-  paidOut?: boolean;
-  asset?: string;
-  assetAddress?: string;
-};
-
-function tabStatusFromRpc(status: RpcTabStatus): TabPaymentStatus {
-  const paid = status.paid !== undefined ? status.paid : (status.paidAmount ?? 0);
-  const remunerated = status.remunerated ?? status.paidOut ?? false;
-  const asset = status.asset ?? status.assetAddress ?? '';
-  return {
-    paid: parseU256(paid),
-    remunerated: Boolean(remunerated),
-    asset,
-  };
-}
-
-export class Client {
-  readonly rpc: RpcProxy;
-  readonly params: CorePublicParameters;
-  readonly gateway: ContractGateway;
-  readonly guaranteeDomain: string;
-  readonly user: UserClient;
-  readonly recipient: RecipientClient;
-  readonly signer: PaymentSigner;
-  private authSession?: AuthSession;
-
-  private constructor(
-    rpc: RpcProxy,
-    params: CorePublicParameters,
-    gateway: ContractGateway,
-    guaranteeDomain: string,
-    signer: PaymentSigner,
-    authSession?: AuthSession
-  ) {
-    this.rpc = rpc;
-    this.params = params;
-    this.gateway = gateway;
-    this.guaranteeDomain = guaranteeDomain;
-    this.signer = signer;
-    this.authSession = authSession;
-    this.user = new UserClient(this);
-    this.recipient = new RecipientClient(this);
-  }
-
-  static async new(cfg: Config): Promise<Client> {
-    const rpc = new RpcProxy(cfg.rpcUrl, cfg.adminApiKey);
-    const params = await rpc.getPublicParams();
-    const gateway = Client.buildGateway(cfg, params);
-    await Client.validateChainId(gateway, params.chainId);
-    const guaranteeDomain = await gateway.getGuaranteeDomain();
-    const signer = new PaymentSigner(cfg.signer);
-    const authEnabled = cfg.authUrl !== undefined || cfg.authRefreshMarginSecs !== undefined;
-    const authSession =
-      cfg.bearerToken || !authEnabled
-        ? undefined
-        : new AuthSession({
-            authUrl: cfg.authUrl ?? cfg.rpcUrl,
-            signer: cfg.signer,
-            refreshMarginSecs: cfg.authRefreshMarginSecs ?? 60,
-          });
-
-    if (cfg.bearerToken) {
-      rpc.withBearerToken(cfg.bearerToken);
-    } else if (authSession) {
-      rpc.withTokenProvider(() => authSession.accessToken());
-    }
-    return new Client(rpc, params, gateway, guaranteeDomain, signer, authSession);
-  }
-
-  private static buildGateway(cfg: Config, params: CorePublicParameters): ContractGateway {
-    const ethRpcUrl = cfg.ethereumHttpRpcUrl ?? params.ethereumHttpRpcUrl;
-    const contractAddress = cfg.contractAddress ?? params.contractAddress;
-    return new ContractGateway(ethRpcUrl, cfg.walletPrivateKey, contractAddress, params.chainId);
-  }
-
-  private static async validateChainId(
-    gateway: ContractGateway,
-    expectedChainId: number
-  ): Promise<void> {
-    try {
-      const chainId = await gateway.getChainId();
-      if (Number(chainId) !== Number(expectedChainId)) {
-        throw new ClientInitializationError(
-          `chain id mismatch between core (${expectedChainId}) and provider (${chainId})`
-        );
-      }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new ClientInitializationError(message);
-    }
-  }
-
-  async aclose(): Promise<void> {
-    await this.rpc.aclose();
-  }
-
-  async login(): Promise<AuthTokens> {
-    if (!this.authSession) {
-      throw new AuthMissingConfigError('auth is not enabled');
-    }
-    return this.authSession.login();
-  }
-}
-
-export class UserClient {
-  constructor(private client: Client) {}
-
-  get guaranteeDomain(): string {
-    return this.client.guaranteeDomain;
-  }
-
-  async approveErc20(token: string, amount: number | bigint | string) {
-    return this.client.gateway.approveErc20(token, amount);
-  }
-
-  async deposit(amount: number | bigint | string, erc20Token?: string) {
-    return this.client.gateway.deposit(amount, erc20Token);
-  }
-
-  async getUser(): Promise<UserInfo[]> {
-    const assets = await this.client.gateway.getUserAssets();
-    return assets.map(
-      (a) =>
-        ({
-          asset: a.asset,
-          collateral: parseU256(a.collateral),
-          withdrawalRequestAmount: parseU256(a.withdrawal_request_amount),
-          withdrawalRequestTimestamp: Number(a.withdrawal_request_timestamp),
-        }) satisfies UserInfo
-    );
-  }
-
-  async getTabPaymentStatus(tabId: number | bigint): Promise<TabPaymentStatus> {
-    const status = await this.client.gateway.getPaymentStatus(tabId);
-    return tabStatusFromRpc(status);
-  }
-
-  async signPayment(
-    claims: PaymentGuaranteeRequestClaims,
-    scheme: SigningScheme = SigningScheme.EIP712
-  ): Promise<PaymentSignature> {
-    return this.client.signer.signRequest(this.client.params, claims, scheme);
-  }
-
-  async payTab(
-    tabId: number | bigint,
-    reqId: number | bigint,
-    amount: number | bigint | string,
-    recipientAddress: string,
-    erc20Token?: string
-  ) {
-    if (erc20Token) {
-      return this.client.gateway.payTabErc20(tabId, amount, erc20Token, recipientAddress);
-    }
-    return this.client.gateway.payTabEth(tabId, reqId, amount, recipientAddress);
-  }
-
-  async requestWithdrawal(amount: number | bigint | string, erc20Token?: string) {
-    return this.client.gateway.requestWithdrawal(amount, erc20Token);
-  }
-
-  async cancelWithdrawal(erc20Token?: string) {
-    return this.client.gateway.cancelWithdrawal(erc20Token);
-  }
-
-  async finalizeWithdrawal(erc20Token?: string) {
-    return this.client.gateway.finalizeWithdrawal(erc20Token);
-  }
-}
-
-export class RecipientClient {
-  constructor(private client: Client) {}
-
-  private get recipientAddress(): string {
-    return normalizeAddress(this.client.gateway.wallet.address);
-  }
-
-  get guaranteeDomain(): string {
-    return this.client.guaranteeDomain;
-  }
-
-  private checkSigner(expected: string): void {
-    if (normalizeAddress(expected) !== this.recipientAddress) {
-      throw new VerificationError('signer address does not match recipient address');
-    }
-  }
-
-  async createTab(
-    userAddress: string,
-    recipientAddress: string,
-    erc20Token: string | undefined | null,
-    ttl?: number | null
-  ): Promise<bigint> {
-    this.checkSigner(recipientAddress);
-    const body = {
-      user_address: normalizeAddress(userAddress),
-      recipient_address: normalizeAddress(recipientAddress),
-      erc20_token: erc20Token ? normalizeAddress(erc20Token) : null,
-      ttl: ttl ?? null,
-    };
-    const result = await this.client.rpc.createPaymentTab(body);
-    const record = result as Record<string, unknown>;
-    const tabIdRaw = record.id ?? record.tabId ?? record.tab_id;
-    const tabId = isNumericLike(tabIdRaw) ? tabIdRaw : 0;
-    return parseU256(tabId);
-  }
-
-  async getTabPaymentStatus(tabId: number | bigint): Promise<TabPaymentStatus> {
-    const status = await this.client.gateway.getPaymentStatus(tabId);
-    return tabStatusFromRpc(status);
-  }
-
-  async issuePaymentGuarantee(
-    claims: PaymentGuaranteeRequestClaims,
-    signature: string,
-    scheme: SigningScheme
-  ): Promise<BLSCert> {
-    this.checkSigner(claims.recipientAddress);
-    const payload = {
-      claims: {
-        version: 'v1',
-        user_address: claims.userAddress,
-        recipient_address: claims.recipientAddress,
-        tab_id: serializeU256(claims.tabId),
-        req_id: serializeU256(claims.reqId),
-        amount: serializeU256(claims.amount),
-        asset_address: claims.assetAddress,
-        timestamp: Number(claims.timestamp),
-      },
-      signature,
-      scheme,
-    };
-    const cert = await this.client.rpc.issueGuarantee(payload);
-    const record = cert as Record<string, unknown>;
-    const certClaims = typeof record.claims === 'string' ? record.claims : '';
-    const signatureOut = typeof record.signature === 'string' ? record.signature : '';
-    return { claims: certClaims, signature: signatureOut };
-  }
-
-  verifyPaymentGuarantee(cert: BLSCert): PaymentGuaranteeClaims {
-    const claims = decodeGuaranteeClaims(cert.claims);
-    const domainHex = this.guaranteeDomain.startsWith('0x')
-      ? this.guaranteeDomain.slice(2)
-      : Buffer.from(this.guaranteeDomain).toString('hex');
-    const claimsHex = Buffer.from(claims.domain).toString('hex');
-    if (claimsHex !== domainHex) {
-      throw new VerificationError('guarantee domain mismatch');
-    }
-    return claims;
-  }
-
-  async remunerate(cert: BLSCert) {
-    this.verifyPaymentGuarantee(cert);
-    const sigWords = signatureToWords(cert.signature);
-    const claimsBytes = Buffer.from(cert.claims.replace(/^0x/, ''), 'hex');
-    return this.client.gateway.remunerate(claimsBytes, sigWords);
-  }
-
-  async listSettledTabs(): Promise<TabInfo[]> {
-    const tabs = await this.client.rpc.listSettledTabs(this.recipientAddress);
-    return tabs.map((t) => TabInfo.fromRpc(t));
-  }
-
-  async listPendingRemunerations(): Promise<PendingRemunerationInfo[]> {
-    const items = await this.client.rpc.listPendingRemunerations(this.recipientAddress);
-    return items.map((item) => PendingRemunerationInfo.fromRpc(item));
-  }
-
-  async getTab(tabId: number | bigint): Promise<TabInfo | null> {
-    const result = await this.client.rpc.getTab(tabId);
-    return result ? TabInfo.fromRpc(result) : null;
-  }
-
-  async listRecipientTabs(settlementStatuses?: string[]): Promise<TabInfo[]> {
-    const tabs = await this.client.rpc.listRecipientTabs(this.recipientAddress, settlementStatuses);
-    return tabs.map((t) => TabInfo.fromRpc(t));
-  }
-
-  async getTabGuarantees(tabId: number | bigint): Promise<GuaranteeInfo[]> {
-    const guarantees = await this.client.rpc.getTabGuarantees(tabId);
-    return guarantees.map((g) => GuaranteeInfo.fromRpc(g));
-  }
-
-  async getLatestGuarantee(tabId: number | bigint): Promise<GuaranteeInfo | null> {
-    const result = await this.client.rpc.getLatestGuarantee(tabId);
-    return result ? GuaranteeInfo.fromRpc(result) : null;
-  }
-
-  async getGuarantee(
-    tabId: number | bigint,
-    reqId: number | bigint
-  ): Promise<GuaranteeInfo | null> {
-    const result = await this.client.rpc.getGuarantee(tabId, reqId);
-    return result ? GuaranteeInfo.fromRpc(result) : null;
-  }
-
-  async listRecipientPayments(): Promise<RecipientPaymentInfo[]> {
-    const payments = await this.client.rpc.listRecipientPayments(this.recipientAddress);
-    return payments.map((p) => RecipientPaymentInfo.fromRpc(p));
-  }
-
-  async getCollateralEventsForTab(tabId: number | bigint): Promise<CollateralEventInfo[]> {
-    const events = await this.client.rpc.getCollateralEventsForTab(tabId);
-    return events.map((ev) => CollateralEventInfo.fromRpc(ev));
-  }
-
-  async getUserAssetBalance(
-    userAddress: string,
-    assetAddress: string
-  ): Promise<AssetBalanceInfo | null> {
-    const balance = await this.client.rpc.getUserAssetBalance(userAddress, assetAddress);
-    return balance ? AssetBalanceInfo.fromRpc(balance) : null;
-  }
-}

package/src/config.ts

@@ -1,149 +0,0 @@
-import { ConfigError } from './errors';
-import { createLocalSigner, EvmSigner } from './signing';
-import { ValidationError, normalizeAddress, normalizePrivateKey, validateUrl } from './utils';
-
-export interface Config {
-  rpcUrl: string;
-  walletPrivateKey: string;
-  signer: EvmSigner;
-  ethereumHttpRpcUrl?: string;
-  contractAddress?: string;
-  adminApiKey?: string;
-  bearerToken?: string;
-  authUrl?: string;
-  authRefreshMarginSecs?: number;
-}
-
-export class ConfigBuilder {
-  private _rpcUrl: string | undefined = 'http://127.0.0.1:3000';
-  private _walletPrivateKey: string | undefined;
-  private _signer: EvmSigner | undefined;
-  private _ethereumHttpRpcUrl?: string;
-  private _contractAddress?: string;
-  private _adminApiKey?: string;
-  private _bearerToken?: string;
-  private _authEnabled = false;
-  private _authUrl?: string;
-  private _authRefreshMarginSecs?: number;
-
-  rpcUrl(value: string): ConfigBuilder {
-    this._rpcUrl = value;
-    return this;
-  }
-
-  walletPrivateKey(value: string): ConfigBuilder {
-    this._walletPrivateKey = value;
-    return this;
-  }
-
-  signer(value: EvmSigner): ConfigBuilder {
-    this._signer = value;
-    return this;
-  }
-
-  ethereumHttpRpcUrl(value: string): ConfigBuilder {
-    this._ethereumHttpRpcUrl = value;
-    return this;
-  }
-
-  contractAddress(value: string): ConfigBuilder {
-    this._contractAddress = value;
-    return this;
-  }
-
-  adminApiKey(value: string): ConfigBuilder {
-    this._adminApiKey = value;
-    return this;
-  }
-
-  bearerToken(value: string): ConfigBuilder {
-    this._bearerToken = value;
-    return this;
-  }
-
-  enableAuth(): ConfigBuilder {
-    this._authEnabled = true;
-    return this;
-  }
-
-  authUrl(value: string): ConfigBuilder {
-    this._authUrl = value;
-    this._authEnabled = true;
-    return this;
-  }
-
-  authRefreshMarginSecs(value: number): ConfigBuilder {
-    this._authRefreshMarginSecs = value;
-    this._authEnabled = true;
-    return this;
-  }
-
-  fromEnv(): ConfigBuilder {
-    const env = process.env;
-    if (env['4MICA_RPC_URL']) this._rpcUrl = env['4MICA_RPC_URL'];
-    if (env['4MICA_WALLET_PRIVATE_KEY']) this._walletPrivateKey = env['4MICA_WALLET_PRIVATE_KEY'];
-    if (env['4MICA_ETHEREUM_HTTP_RPC_URL'])
-      this._ethereumHttpRpcUrl = env['4MICA_ETHEREUM_HTTP_RPC_URL'];
-    if (env['4MICA_CONTRACT_ADDRESS']) this._contractAddress = env['4MICA_CONTRACT_ADDRESS'];
-    if (env['4MICA_ADMIN_API_KEY']) this._adminApiKey = env['4MICA_ADMIN_API_KEY'];
-    if (env['4MICA_BEARER_TOKEN']) this._bearerToken = env['4MICA_BEARER_TOKEN'];
-    if (env['4MICA_AUTH_URL']) {
-      this._authUrl = env['4MICA_AUTH_URL'];
-      this._authEnabled = true;
-    }
-    if (env['4MICA_AUTH_REFRESH_MARGIN_SECS']) {
-      this._authRefreshMarginSecs = Number(env['4MICA_AUTH_REFRESH_MARGIN_SECS']);
-      this._authEnabled = true;
-    }
-    return this;
-  }
-
-  build(): Config {
-    if (!this._signer && !this._walletPrivateKey) {
-      throw new ConfigError('missing signer or wallet_private_key');
-    }
-    if (!this._rpcUrl) {
-      throw new ConfigError('missing rpc_url');
-    }
-
-    try {
-      const rpcUrl = validateUrl(this._rpcUrl);
-      const walletPrivateKey = this._walletPrivateKey
-        ? normalizePrivateKey(this._walletPrivateKey)
-        : undefined;
-
-      const signer: EvmSigner = this._signer ?? createLocalSigner(walletPrivateKey!);
-
-      const ethereumHttpRpcUrl = this._ethereumHttpRpcUrl
-        ? validateUrl(this._ethereumHttpRpcUrl)
-        : undefined;
-      const contractAddress = this._contractAddress
-        ? normalizeAddress(this._contractAddress)
-        : undefined;
-      const authUrl = this._authUrl ? validateUrl(this._authUrl) : undefined;
-      const refreshMargin =
-        this._authRefreshMarginSecs !== undefined ? this._authRefreshMarginSecs : 60;
-      if (!Number.isFinite(refreshMargin) || refreshMargin < 0) {
-        throw new ValidationError('invalid auth refresh margin');
-      }
-      const authEnabled = this._authEnabled;
-
-      return {
-        rpcUrl,
-        walletPrivateKey: walletPrivateKey ?? signer.address,
-        signer,
-        ethereumHttpRpcUrl,
-        contractAddress,
-        adminApiKey: this._adminApiKey,
-        bearerToken: this._bearerToken,
-        authUrl: authEnabled ? (authUrl ?? rpcUrl) : undefined,
-        authRefreshMarginSecs: authEnabled ? refreshMargin : undefined,
-      };
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        throw new ConfigError(err.message);
-      }
-      throw err;
-    }
-  }
-}

package/src/contract.ts

@@ -1,194 +0,0 @@
-import {
-  Contract,
-  InterfaceAbi,
-  JsonRpcProvider,
-  Wallet,
-  getBytes,
-  hexlify,
-  toBeHex,
-} from 'ethers';
-import core4micaAbi from './abi/core4mica.json';
-import erc20Abi from './abi/erc20.json';
-import { ContractError } from './errors';
-import { parseU256 } from './utils';
-
-type ContractFactory = (address: string, abi: unknown, signer: Wallet) => Contract;
-
-export class ContractGateway {
-  readonly provider: JsonRpcProvider;
-  readonly wallet: Wallet;
-  readonly contract: Contract;
-  private erc20Cache: Map<string, Contract> = new Map();
-
-  constructor(
-    ethRpcUrl: string,
-    privateKey: string,
-    contractAddress: string,
-    chainId: number | bigint,
-    provider?: JsonRpcProvider,
-    contractFactory?: ContractFactory
-  ) {
-    const parsedChainId = Number(chainId);
-    if (!Number.isFinite(parsedChainId)) {
-      throw new ContractError(`invalid chain id: ${chainId}`);
-    }
-    const networkish = { chainId: parsedChainId, name: `chain-${parsedChainId}` };
-    this.provider = provider ?? new JsonRpcProvider(ethRpcUrl, networkish);
-    this.wallet = new Wallet(privateKey, this.provider);
-    const factory: ContractFactory =
-      contractFactory ??
-      ((addr, abi, signer) => {
-        const resolvedAbi = (abi as { abi?: InterfaceAbi }).abi ?? (abi as InterfaceAbi);
-        return new Contract(addr, resolvedAbi as InterfaceAbi, signer);
-      });
-    this.contract = factory(contractAddress, core4micaAbi, this.wallet);
-  }
-
-  async getChainId(): Promise<number> {
-    const network = await this.provider.getNetwork();
-    return Number(network.chainId);
-  }
-
-  private erc20(address: string): Contract {
-    const checksum = address;
-    if (!this.erc20Cache.has(checksum)) {
-      this.erc20Cache.set(checksum, new Contract(checksum, erc20Abi.abi ?? erc20Abi, this.wallet));
-    }
-    return this.erc20Cache.get(checksum)!;
-  }
-
-  private async send<T>(promise: Promise<unknown>): Promise<T> {
-    try {
-      const tx = await promise;
-      if (typeof (tx as { wait?: unknown }).wait === 'function') {
-        return await (tx as { wait: () => Promise<T> }).wait();
-      }
-      return tx as T;
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new ContractError(message);
-    }
-  }
-
-  async getGuaranteeDomain(): Promise<string> {
-    return this.send<string>(this.contract.guaranteeDomainSeparator());
-  }
-
-  async approveErc20(token: string, amount: number | bigint | string): Promise<unknown> {
-    const erc20 = this.erc20(token);
-    const { target, address } = this.contract as { target?: string; address?: string };
-    const spender = target ?? address ?? token;
-    return this.send(erc20.approve(spender, parseU256(amount)));
-  }
-
-  async deposit(amount: number | bigint | string, erc20Token?: string): Promise<unknown> {
-    if (erc20Token) {
-      return this.send(this.contract.depositStablecoin(erc20Token, parseU256(amount)));
-    }
-    return this.send(
-      this.contract.deposit({
-        value: parseU256(amount),
-      })
-    );
-  }
-
-  async getUserAssets(): Promise<
-    {
-      asset: string;
-      collateral: bigint;
-      withdrawal_request_timestamp: bigint;
-      withdrawal_request_amount: bigint;
-    }[]
-  > {
-    try {
-      const result = await this.contract.getUserAllAssets(this.wallet.address);
-      return (
-        result as Array<
-          [string, number | bigint | string, number | bigint | string, number | bigint | string]
-        >
-      ).map((asset) => ({
-        asset: asset[0],
-        collateral: parseU256(asset[1]),
-        withdrawal_request_timestamp: parseU256(asset[2]),
-        withdrawal_request_amount: parseU256(asset[3]),
-      }));
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new ContractError(message);
-    }
-  }
-
-  async getPaymentStatus(tabId: number | bigint): Promise<{
-    paid: bigint;
-    remunerated: boolean;
-    asset: string;
-  }> {
-    try {
-      const [paid, remunerated, asset] = await this.contract.getPaymentStatus(parseU256(tabId));
-      return {
-        paid: parseU256(paid),
-        remunerated: Boolean(remunerated),
-        asset,
-      };
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new ContractError(message);
-    }
-  }
-
-  async payTabEth(
-    tabId: number | bigint,
-    reqId: number | bigint,
-    amount: number | bigint | string,
-    recipient: string
-  ): Promise<unknown> {
-    const data = Buffer.from(
-      `tab_id:${toBeHex(parseU256(tabId))};req_id:${toBeHex(parseU256(reqId))}`
-    );
-    const tx = {
-      to: recipient,
-      value: parseU256(amount),
-      data: hexlify(data),
-    };
-    return this.send(this.wallet.sendTransaction(tx));
-  }
-
-  async payTabErc20(
-    tabId: number | bigint,
-    amount: number | bigint | string,
-    erc20Token: string,
-    recipient: string
-  ): Promise<unknown> {
-    return this.send(
-      this.contract.payTabInERC20Token(parseU256(tabId), erc20Token, parseU256(amount), recipient)
-    );
-  }
-
-  async requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<unknown> {
-    if (erc20Token) {
-      return this.send(
-        this.contract['requestWithdrawal(address,uint256)'](erc20Token, parseU256(amount))
-      );
-    }
-    return this.send(this.contract['requestWithdrawal(uint256)'](parseU256(amount)));
-  }
-
-  async cancelWithdrawal(erc20Token?: string): Promise<unknown> {
-    if (erc20Token) {
-      return this.send(this.contract['cancelWithdrawal(address)'](erc20Token));
-    }
-    return this.send(this.contract['cancelWithdrawal()']());
-  }
-
-  async finalizeWithdrawal(erc20Token?: string): Promise<unknown> {
-    if (erc20Token) {
-      return this.send(this.contract['finalizeWithdrawal(address)'](erc20Token));
-    }
-    return this.send(this.contract['finalizeWithdrawal()']());
-  }
-
-  async remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[]): Promise<unknown> {
-    const sigStruct = signatureWords.map((word) => hexlify(getBytes(word)));
-    return this.send(this.contract.remunerate(hexlify(claimsBlob), sigStruct));
-  }
-}