@thesingularitynetwork/darkswap-sdk 0.1.18 → 0.1.19

package/src/proof/retail/depositOrderProof.ts

@@ -1,133 +0,0 @@
-import { BaseProofInput, BaseProofParam, BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, PROOF_DOMAIN } from "../../types";
-import { encodeAddress } from "../../utils/encoders";
-import { bn_to_0xhex } from "../../utils/formatters";
-import { bn_to_hex } from "../../utils/formatters";
-import { mimc_bn254 } from "../../utils/mimc";
-import { signatureToHexString, uint8ArrayToNumberArray } from "../../utils/proofUtils";
-import { generateProof, signMessage } from "../baseProofService";
-import { generateKeyPair } from "../keyService";
-import { calcNullifier, getNoteFooter } from "../noteService";
-import retailCreateOrderCircuit from "../../circuits/retail/dark_swap_retail_deposit_create_order_compiled_circuit.json";
-import { Fr } from "../../aztec/fields/fields";
-
-type RetailCreateOrderProofInput = BaseProofInput & {
-    deposit_out_note: string,
-    deposit_out_nullifier: string,
-    deposit_out_note_footer: string,
-    deposit_out_rho: string,
-
-    //order
-    out_asset: string,
-    out_amount: string,
-    in_asset: string,
-    in_amount: string,
-
-    //fee
-    fee_ratio: string,
-    fee_amount: string,
-
-    //swap in 
-    in_note: string,
-    in_note_footer: string,
-    in_rho: string,
-}
-
-export type RetailCreateOrderProofParam = BaseProofParam & {
-    depositNote: DarkSwapOrderNote,
-    swapInNote: DarkSwapNote,
-    feeAmount: bigint
-}
-
-export type RetailCreateOrderProofResult = BaseProofResult & {
-    depositNullifier: string,
-    depositFooter: string,
-    swapInNoteFooter: string,
-}
-
-export async function generateRetailSwapMessage(
-    address: string,
-    orderNote: DarkSwapOrderNote,
-    swapInNote: DarkSwapNote,
-    feeAmount: bigint,
-    pubKey: [Fr, Fr],
-    privKey: Fr
-): Promise<DarkSwapMessage> {
-
-    const addressMod = encodeAddress(address);
-    const orderNoteNullifier = calcNullifier(orderNote.rho, pubKey);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
-        addressMod,
-        orderNoteNullifier,
-        orderNote.feeRatio,
-        swapInNote.note,
-    ]));
-    const signature = await signMessage(message, privKey);
-
-    return {
-        address: address,
-        orderNote: orderNote,
-        orderNullifier: bn_to_0xhex(orderNoteNullifier),
-        inNote: swapInNote,
-        feeAmount: feeAmount,
-        publicKey: pubKey,
-        signature: signatureToHexString(signature),
-    }
-}
-
-export async function generateRetailCreateOrderProof(param: RetailCreateOrderProofParam): Promise<RetailCreateOrderProofResult> {
-    if (param.depositNote.amount <= 0n) {
-        throw new DarkSwapProofError("Deposit amount must be greater than 0");
-    }
-
-    if (param.depositNote.feeRatio < 0n) {
-        throw new DarkSwapProofError("Fee ratio must be greater or equal to 0");
-    }
-
-    const [[fuzkPubKeyX, fuzkPubKeyY], fuzkPriKey] = await generateKeyPair(param.signedMessage);
-
-    const depositNullifier = calcNullifier(param.depositNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const depositFooter = getNoteFooter(param.depositNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const inAmount = param.feeAmount + param.swapInNote.amount;
-
-    const swapInNoteFooter = getNoteFooter(param.swapInNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-
-    const addressMod = encodeAddress(param.address);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
-        addressMod,
-        param.depositNote.note,
-        param.depositNote.feeRatio,
-        param.swapInNote.note,
-    ]));
-    const signature = await signMessage(message, fuzkPriKey);
-
-    const inputs: RetailCreateOrderProofInput = {
-        address: bn_to_0xhex(addressMod),
-        deposit_out_note: bn_to_0xhex(param.depositNote.note),
-        deposit_out_nullifier: bn_to_0xhex(depositNullifier),
-        deposit_out_note_footer: bn_to_0xhex(depositFooter),
-        deposit_out_rho: bn_to_0xhex(param.depositNote.rho),
-
-        out_asset: bn_to_0xhex(encodeAddress(param.depositNote.asset)),
-        out_amount: bn_to_0xhex(param.depositNote.amount),
-        in_asset: bn_to_0xhex(encodeAddress(param.swapInNote.asset)),
-        in_amount: bn_to_0xhex(inAmount),
-
-        in_note: bn_to_0xhex(param.swapInNote.note),
-        in_note_footer: bn_to_0xhex(swapInNoteFooter),
-        in_rho: bn_to_0xhex(param.swapInNote.rho),
-        fee_ratio: bn_to_0xhex(param.depositNote.feeRatio),
-        fee_amount: bn_to_0xhex(param.feeAmount),
-
-        pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
-        signature: uint8ArrayToNumberArray(signature),
-    };
-    const proof = await generateProof(retailCreateOrderCircuit, inputs);
-    return {
-        ...proof,
-        depositNullifier: inputs.deposit_out_nullifier,
-        depositFooter: inputs.deposit_out_note_footer,
-        swapInNoteFooter: inputs.in_note_footer,
-    }
-};

package/src/proof/retail/swapProof.ts

@@ -1,158 +0,0 @@
-import retailSwapCircuit from "../../circuits/retail/dark_swap_retail_swap_compiled_circuit.json";
-import { BaseProofResult, DarkSwapMessage, DarkSwapProofError, FEE_RATIO_PRECISION } from "../../types";
-import { encodeAddress } from "../../utils/encoders";
-import { bn_to_0xhex } from "../../utils/formatters";
-import { hexStringToSignature, uint8ArrayToNumberArray } from "../../utils/proofUtils";
-import { generateProof } from "../baseProofService";
-import { calcNullifier, getNoteFooter } from "../noteService";
-
-type RetailSwapProofInput = {
-    merkle_root: string,
-
-    // Alice input
-    alice_merkle_index: number[],
-    alice_merkle_path: string[],
-    alice_address: string,
-    alice_out_note: string,
-    alice_out_rho: string,
-    alice_out_nullifier: string,
-
-    //Alice fee
-    alice_fee_ratio: string,
-    alice_fee_amount: string,
-
-    // Alice output
-    alice_in_note: string,
-    alice_in_rho: string,
-    alice_in_note_footer: string,
-
-    // Alice pub key and signature
-    alice_pub_key: string[],
-    alice_signature: any,
-
-    //order
-    alice_out_asset: string,
-    alice_out_amount: string,
-    alice_in_asset: string,
-    alice_in_amount: string,
-
-    // Bob input
-    bob_merkle_index: number[],
-    bob_merkle_path: string[],
-    bob_address: string,
-    bob_out_note: string,
-    bob_out_rho: string,
-    bob_out_nullifier: string,
-
-    //bob fee
-    bob_fee_ratio: string,
-    bob_fee_amount: string,
-
-    // Bob output
-    bob_in_note: string,
-    bob_in_rho: string,
-    bob_in_note_footer: string,
-
-    // Bob pub key and signature
-    bob_pub_key: string[],
-    bob_signature: any,
-}
-
-export type RetailSwapProofParam = {
-    merkleRoot: string,
-    aliceMerkleIndex: number[],
-    aliceMerklePath: string[],
-    aliceMessage: DarkSwapMessage,
-
-    bobMerkleIndex: number[],
-    bobMerklePath: string[],
-    bobMessage: DarkSwapMessage,
-}
-
-export type RetailSwapProofResult = BaseProofResult & {
-    aliceOrderNullifier: string,
-    aliceInNoteFooter: string,
-    bobOrderNullifier: string,
-    bobInNoteFooter: string,
-}
-
-export async function generateRetailSwapProof(param: RetailSwapProofParam): Promise<RetailSwapProofResult> {
-    if (param.aliceMessage.orderNote.feeRatio < 0n
-        || param.bobMessage.orderNote.feeRatio < 0n) {
-        throw new DarkSwapProofError("Invalid fee ratio");
-    }
-
-    if (param.aliceMessage.inNote.amount <= 0n
-        || param.aliceMessage.orderNote.amount <= 0n
-        || param.aliceMessage.inNote.amount <= 0n
-        || param.bobMessage.inNote.amount <= 0n
-        || param.bobMessage.orderNote.amount <= 0n) {
-        throw new DarkSwapProofError("Invalid note amount");
-    }
-
-    if (param.aliceMessage.orderNote.amount != param.bobMessage.inNote.amount
-        || param.bobMessage.orderNote.amount != param.aliceMessage.inNote.amount) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-
-    const aliceFeeAmount = param.aliceMessage.inNote.amount * param.aliceMessage.orderNote.feeRatio / FEE_RATIO_PRECISION;
-    const bobFeeAmount = param.bobMessage.inNote.amount * param.bobMessage.orderNote.feeRatio / FEE_RATIO_PRECISION;
-
-    const aliceOrderNoteNullifier = calcNullifier(param.aliceMessage.orderNote.rho, param.aliceMessage.publicKey);
-    const aliceInNoteFooter = getNoteFooter(param.aliceMessage.inNote.rho, param.aliceMessage.publicKey);
-    const bobOrderNoteNullifier = calcNullifier(param.bobMessage.orderNote.rho, param.bobMessage.publicKey);
-    const bobInNoteFooter = getNoteFooter(param.bobMessage.inNote.rho, param.bobMessage.publicKey);
-
-    const aliceAddressMod = encodeAddress(param.aliceMessage.address);
-    const bobAddressMod = encodeAddress(param.bobMessage.address);
-
-    const inputs: RetailSwapProofInput = {
-        merkle_root: param.merkleRoot,
-
-        alice_merkle_index: param.aliceMerkleIndex,
-        alice_merkle_path: param.aliceMerklePath.map((x) => bn_to_0xhex(BigInt(x))),
-        alice_address: bn_to_0xhex(aliceAddressMod),
-
-        alice_out_rho: bn_to_0xhex(param.aliceMessage.orderNote.rho),
-        alice_out_asset: bn_to_0xhex(encodeAddress(param.aliceMessage.orderNote.asset)),
-        alice_out_amount: bn_to_0xhex(param.aliceMessage.orderNote.amount),
-        alice_out_note: bn_to_0xhex(param.aliceMessage.orderNote.note),
-        alice_out_nullifier: bn_to_0xhex(aliceOrderNoteNullifier),
-        alice_fee_ratio: bn_to_0xhex(param.aliceMessage.orderNote.feeRatio),
-        alice_fee_amount: bn_to_0xhex(aliceFeeAmount),
-
-        alice_in_rho: bn_to_0xhex(param.aliceMessage.inNote.rho),
-        alice_in_asset: bn_to_0xhex(encodeAddress(param.aliceMessage.inNote.asset)),
-        alice_in_amount: bn_to_0xhex(param.aliceMessage.inNote.amount),
-        alice_in_note: bn_to_0xhex(param.aliceMessage.inNote.note),
-        alice_in_note_footer: bn_to_0xhex(aliceInNoteFooter),
-
-        alice_pub_key: [param.aliceMessage.publicKey[0].toString(), param.aliceMessage.publicKey[1].toString()],
-        alice_signature: uint8ArrayToNumberArray(hexStringToSignature(param.aliceMessage.signature)),
-
-        bob_merkle_index: param.bobMerkleIndex,
-        bob_merkle_path: param.bobMerklePath.map((x) => bn_to_0xhex(BigInt(x))),
-        bob_address: bn_to_0xhex(bobAddressMod),
-
-        bob_out_note: bn_to_0xhex(param.bobMessage.orderNote.note),
-        bob_out_rho: bn_to_0xhex(param.bobMessage.orderNote.rho),
-        bob_out_nullifier: bn_to_0xhex(bobOrderNoteNullifier),
-        bob_fee_ratio: bn_to_0xhex(param.bobMessage.orderNote.feeRatio),
-        bob_fee_amount: bn_to_0xhex(bobFeeAmount),
-
-        bob_in_note: bn_to_0xhex(param.bobMessage.inNote.note),
-        bob_in_rho: bn_to_0xhex(param.bobMessage.inNote.rho),
-        bob_in_note_footer: bn_to_0xhex(bobInNoteFooter),
-
-        bob_pub_key: [param.bobMessage.publicKey[0].toString(), param.bobMessage.publicKey[1].toString()],
-        bob_signature: uint8ArrayToNumberArray(hexStringToSignature(param.bobMessage.signature)),
-    };
-    const proof = await generateProof(retailSwapCircuit, inputs);
-    return {
-        ...proof,
-        aliceOrderNullifier: inputs.alice_out_nullifier,
-        aliceInNoteFooter: inputs.alice_in_note_footer,
-        bobOrderNullifier: inputs.bob_out_nullifier,
-        bobInNoteFooter: inputs.bob_in_note_footer,
-    }
-};

package/src/services/BaseService.ts

@@ -1,49 +0,0 @@
-import { DarkSwap } from '../darkSwap';
-
-export class BaseContext {
-  private _address?: string;
-  private _signature: string;
-  private _merkleRoot?: string;
-  private _tx?: string;
-
-  constructor(signature: string) {
-    this._signature = signature;
-  }
-
-  set address(address: string | undefined) {
-    this._address = address;
-  }
-
-  get address(): string | undefined {
-    return this._address;
-  }
-
-  get signature(): string {
-    return this._signature;
-  }
-
-  set merkleRoot(merkleRoot: string | undefined) {
-    this._merkleRoot = merkleRoot;
-  }
-
-  get merkleRoot(): string | undefined {
-    return this._merkleRoot;
-  }
-
-  set tx(tx: string | undefined) {
-    this._tx = tx;
-  }
-
-  get tx(): string | undefined {
-    return this._tx;
-  }
-}
-
-
-export abstract class BaseContractService {
-  protected _darkSwap: DarkSwap;
-
-  constructor(_darkSwap: DarkSwap) {
-    this._darkSwap = _darkSwap;
-  }
-}

package/src/services/EventService.ts

@@ -1,17 +0,0 @@
-import { ethers } from 'ethers';
-import { DarkSwap } from '../darkSwap';
-
-export async function getOutEvent(tx: string, abi: any, eventTopic: string, darkSwap: DarkSwap) {
-  const iface = new ethers.Interface(abi);
-  const receipt = await darkSwap.provider.getTransactionReceipt(tx);
-  if (receipt && receipt.logs.length > 0) {
-    for (let i = 0; i < receipt.logs.length; i++) {
-      const parsedLog = iface.parseLog(receipt.logs[i]);
-      if (parsedLog && parsedLog.name == eventTopic) {
-        return parsedLog;
-      }
-    }
-  }
-
-  return null;
-}

package/src/services/agent/index.ts

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

package/src/services/agent/retailSwap.ts

@@ -1,116 +0,0 @@
-import { ethers } from 'ethers';
-import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-import { DarkSwap } from '../../darkSwap';
-import { DarkSwapError } from '../../entities';
-import { generateRetailSwapProof, RetailSwapProofResult } from '../../proof/retail/swapProof';
-import { DarkSwapMessage } from '../../types';
-import { hexlify32 } from '../../utils/util';
-import { BaseContext, BaseContractService } from '../BaseService';
-import { multiGetMerklePathAndRoot } from '../merkletree';
-
-class RetailSwapContext extends BaseContext {
-    private _aliceSwapMessage?: DarkSwapMessage;
-    private _bobSwapMessage?: DarkSwapMessage;
-    private _proof?: RetailSwapProofResult;
-
-    constructor(signature: string) {
-        super(signature);
-    }
-
-    set aliceSwapMessage(aliceSwapMessage: DarkSwapMessage | undefined) {
-        this._aliceSwapMessage = aliceSwapMessage;
-    }
-
-    get aliceSwapMessage(): DarkSwapMessage | undefined {
-        return this._aliceSwapMessage;
-    }
-
-    set bobSwapMessage(bobSwapMessage: DarkSwapMessage | undefined) {
-        this._bobSwapMessage = bobSwapMessage;
-    }
-
-    get bobSwapMessage(): DarkSwapMessage | undefined {
-        return this._bobSwapMessage;
-    }
-
-    set proof(proof: RetailSwapProofResult | undefined) {
-        this._proof = proof;
-    }
-
-    get proof(): RetailSwapProofResult | undefined {
-        return this._proof;
-    }
-}
-
-export class RetailSwapService extends BaseContractService {
-    constructor(_darkSwap: DarkSwap) {
-        super(_darkSwap);
-    }
-
-    public async prepare(
-        aliceSwapMessage: DarkSwapMessage,
-        bobSwapMessage: DarkSwapMessage
-    ): Promise<{ context: RetailSwapContext }> {
-        const context = new RetailSwapContext(aliceSwapMessage.signature);
-        context.aliceSwapMessage = aliceSwapMessage;
-        context.bobSwapMessage = bobSwapMessage;
-        return { context };
-    }
-
-    private async generateProof(context: RetailSwapContext): Promise<void> {
-        if (!context
-            || !context.aliceSwapMessage
-            || !context.bobSwapMessage) {
-            throw new DarkSwapError('Invalid context');
-        }
-
-        const merklePathes = await multiGetMerklePathAndRoot([context.aliceSwapMessage.orderNote.note, context.bobSwapMessage.orderNote.note], this._darkSwap);
-        const aliceOrderNotePath = merklePathes[0];
-        const bobOrderNotePath = merklePathes[1];
-
-        const proof = await generateRetailSwapProof({
-            merkleRoot: aliceOrderNotePath.root,
-            aliceMerkleIndex: aliceOrderNotePath.index,
-            aliceMerklePath: aliceOrderNotePath.path,
-            aliceMessage: context.aliceSwapMessage,
-            bobMerkleIndex: bobOrderNotePath.index,
-            bobMerklePath: bobOrderNotePath.path,
-            bobMessage: context.bobSwapMessage,
-        });
-        context.merkleRoot = aliceOrderNotePath.root;
-        context.proof = proof;
-    }
-
-    public async execute(context: RetailSwapContext): Promise<string> {
-        await this.generateProof(context);
-        if (!context
-            || !context.merkleRoot
-            || !context.aliceSwapMessage
-            || !context.bobSwapMessage
-            || !context.proof) {
-            throw new DarkSwapError('Invalid context');
-        }
-
-        const contract = new ethers.Contract(
-            this._darkSwap.contracts.darkSwapAssetManager,
-            DarkSwapAssetManagerAbi.abi,
-            this._darkSwap.signer
-        );
-        const tx = await contract.retailSwap(
-            [
-                context.merkleRoot,
-                hexlify32(context.aliceSwapMessage.orderNote.feeRatio),
-                context.proof.aliceOrderNullifier,
-                hexlify32(context.aliceSwapMessage.inNote.note),
-                context.proof.aliceInNoteFooter,
-                hexlify32(context.bobSwapMessage.orderNote.feeRatio),
-                context.proof.bobOrderNullifier,
-                hexlify32(context.bobSwapMessage.inNote.note),
-                context.proof.bobInNoteFooter
-            ],
-            context.proof.proof
-        );
-        await tx.wait();
-        return tx.hash;
-    }
-}

package/src/services/base/deposit.ts

@@ -1,174 +0,0 @@
-import { ethers } from 'ethers';
-import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-import ERC20Abi from '../../abis/IERC20.json';
-import ERC20_USDT from '../../abis/IERC20_USDT.json';
-import { legacyTokenConfig } from '../../config/config';
-import { DarkSwap } from '../../darkSwap';
-import { DarkSwapError } from '../../entities';
-import { DepositProofResult, generateDepositProof } from '../../proof/basic/depositProof';
-import { generateKeyPair } from '../../proof/keyService';
-import { createNote } from '../../proof/noteService';
-import { DarkSwapNote } from '../../types';
-import { MAX_ALLOWANCE } from '../../utils/constants';
-import { hexlify32, isNativeAsset } from '../../utils/util';
-import { BaseContext, BaseContractService } from '../BaseService';
-import { EMPTY_PATH, getMerklePathAndRoot } from '../merkletree';
-
-export class DepositContext extends BaseContext {
-  private _currentBalance?: DarkSwapNote;
-  private _newBalance?: DarkSwapNote;
-  private _proof?: DepositProofResult;
-  private _depositAmount?: bigint;
-
-  constructor(signature: string) {
-    super(signature);
-  }
-
-  set currentBalance(currentBalance: DarkSwapNote | undefined) {
-    this._currentBalance = currentBalance;
-  }
-
-  get currentBalance(): DarkSwapNote | undefined {
-    return this._currentBalance;
-  }
-
-  set newBalance(newBalance: DarkSwapNote | undefined) {
-    this._newBalance = newBalance;
-  }
-
-  get newBalance(): DarkSwapNote | undefined {
-    return this._newBalance;
-  }
-
-  set proof(proof: DepositProofResult | undefined) {
-    this._proof = proof;
-  }
-
-  get proof(): DepositProofResult | undefined {
-    return this._proof;
-  }
-
-  set depositAmount(depositAmount: bigint | undefined) {
-    this._depositAmount = depositAmount;
-  }
-
-  get depositAmount(): bigint | undefined {
-    return this._depositAmount;
-  }
-}
-
-export class DepositService extends BaseContractService {
-  constructor(_darkSwap: DarkSwap) {
-    super(_darkSwap);
-  }
-
-  public async prepare(
-    currentBalance: DarkSwapNote,
-    depositAsset: string,
-    depositAmount: bigint,
-    walletAddress: string,
-    signature: string,
-  ): Promise<{ context: DepositContext; newBalanceNote: DarkSwapNote }> {
-    const [pubKey] = await generateKeyPair(signature);
-    const newBalanceAmount = depositAmount + currentBalance.amount;
-    const newBalance = createNote(walletAddress, depositAsset, newBalanceAmount, pubKey);
-    const context = new DepositContext(signature);
-    context.currentBalance = currentBalance;
-    context.newBalance = newBalance;
-    context.address = walletAddress;
-    context.depositAmount = depositAmount;
-    return { context, newBalanceNote: newBalance };
-  }
-
-  private async generateProof(context: DepositContext): Promise<void> {
-    if (!context || !context.currentBalance || !context.newBalance || !context.address || !context.signature) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const path = context.currentBalance.amount === 0n ?
-      EMPTY_PATH :
-      await getMerklePathAndRoot(context.currentBalance.note, this._darkSwap);
-    context.merkleRoot = path.root;
-
-    const proof = await generateDepositProof({
-      merkleRoot: path.root,
-      merkleIndex: path.index,
-      merklePath: path.path,
-      oldBalanceNote: context.currentBalance,
-      newBalanceNote: context.newBalance,
-      signedMessage: context.signature,
-      address: context.address,
-    });
-    context.proof = proof;
-  }
-
-  public async execute(context: DepositContext): Promise<string> {
-    await this.generateProof(context);
-
-    if (!context 
-      || !context.currentBalance 
-      || !context.newBalance 
-      || !context.address 
-      || !context.signature 
-      || !context.proof
-      || !context.depositAmount
-    ) {
-      throw new DarkSwapError('Invalid context');
-    }
-    const signer = this._darkSwap.signer;
-    const contract = new ethers.Contract(
-      this._darkSwap.contracts.darkSwapAssetManager,
-      DarkSwapAssetManagerAbi.abi,
-      signer
-    );
-
-    if (!isNativeAsset(context.newBalance.asset)) {
-      await this.allowance(context);
-      const tx = await contract.deposit(
-        context.merkleRoot,
-        context.newBalance.asset,
-        hexlify32(context.depositAmount),
-        context.proof.oldBalanceNullifier,
-        hexlify32(context.newBalance.note),
-        context.proof.newBalanceFooter,
-        context.proof.proof,
-        { value: 0n }
-      );
-      await tx.wait();
-      return tx.hash;
-    } else {
-      const tx = await contract.deposit(
-        context.merkleRoot,
-        context.newBalance.asset,
-        hexlify32(context.depositAmount),
-        context.proof.oldBalanceNullifier,
-        hexlify32(context.newBalance.note),
-        context.proof.newBalanceFooter,
-        context.proof.proof,
-        { value: context.depositAmount }
-      );
-      await tx.wait();
-      return tx.hash;
-    }
-  }
-
-  protected async allowance(context: DepositContext) {
-    if (!context || !context.newBalance || !context.address || !context.signature || !context.proof) {
-      throw new DarkSwapError('Invalid context');
-    }
-    const signer = this._darkSwap.signer;
-    const allowanceContract = new ethers.Contract(context.newBalance.asset, ERC20Abi.abi, this._darkSwap);
-    const allowance = await allowanceContract.allowance(
-      signer.getAddress(),
-      this._darkSwap.contracts.darkSwapAssetManager
-    );
-    if (BigInt(allowance) < context.newBalance.amount) {
-      const isLegacy =
-        legacyTokenConfig.hasOwnProperty(this._darkSwap.chainId) &&
-        legacyTokenConfig[this._darkSwap.chainId].includes(context.newBalance.asset.toLowerCase());
-      const contract = new ethers.Contract(context.newBalance.asset, isLegacy ? ERC20_USDT.abi : ERC20Abi.abi, signer);
-      const tx = await contract.approve(this._darkSwap.contracts.darkSwapAssetManager, hexlify32(MAX_ALLOWANCE));
-      await tx.wait();
-    }
-  }
-}

package/src/services/base/index.ts

@@ -1,4 +0,0 @@
-export * from './deposit';
-export * from './withdraw';
-export * from './join';
-export * from './tripleJoin';