@thesingularitynetwork/darkswap-sdk 0.1.18 → 0.1.19

package/src/proof/noteService.ts

@@ -1,114 +0,0 @@
-import { hexlify } from 'ethers'
-import { DarkSwapNote, DarkSwapNoteExt, DarkSwapOrderNote } from '../types'
-import { P } from '../utils/constants'
-import { encodeAddress } from '../utils/encoders'
-import { mimc_bn254 } from '../utils/mimc'
-import { Fr } from '../aztec/fields/fields'
-
-let getRandomValues: (buf: Uint8Array) => Uint8Array;
-
-if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
-    getRandomValues = (buf) => window.crypto.getRandomValues(buf);
-} else {
-    const nodeCrypto = require('crypto');
-    getRandomValues = (buf) => {
-        const randomBytes = nodeCrypto.randomBytes(buf.length);
-        buf.set(randomBytes);
-        return buf;
-    };
-}
-
-export const DOMAIN_NOTE = 2n
-export const DOMAIN_ORDER_NOTE = 3n
-
-export const EMPTY_NOTE: DarkSwapNote = {
-  address: '0x0000000000000000000000000000000000000000',
-  rho: 0n,
-  note: 0n,
-  amount: 0n,
-  asset: '0x0000000000000000000000000000000000000000',
-}
-
-export function createNote(
-  address: string,
-  asset: string,
-  amount: bigint,
-  fuzkPubKey: [Fr, Fr]
-): DarkSwapNoteExt {
-  const rho = generateRho()
-  const footer = getNoteFooter(rho, fuzkPubKey)
-
-  const addressMod = encodeAddress(address)
-  const assetMod = encodeAddress(asset)
-  const note = mimc_bn254([DOMAIN_NOTE, addressMod, assetMod, amount, footer])
-  return {
-    address,
-    rho,
-    note,
-    asset,
-    amount,
-    footer,
-  }
-}
-
-export function getNoteFooter(rho: bigint, publicKey: [Fr, Fr]): bigint {
-  return mimc_bn254([
-    mimc_bn254([BigInt(rho)]),
-    BigInt(publicKey[0].toString()),
-    BigInt(publicKey[1].toString()),
-  ])
-}
-
-function generateRho(): bigint {
-  const securityLevel = 128
-  const primeByteLength = Math.ceil(P.toString(2).length / 8)
-  const totalBytes = primeByteLength + Math.ceil(securityLevel / 8)
-
-  let rho = BigInt(0)
-  do {
-    let ab = new ArrayBuffer(totalBytes)
-    let buf = new Uint8Array(ab)
-    rho = BigInt(hexlify(getRandomValues(buf))) % P
-  } while (rho === BigInt(0))
-
-  return rho
-}
-
-export function calcNullifier(rho: bigint, fuzkPubKey: [Fr, Fr]): bigint {
-  return mimc_bn254([
-    rho,
-    BigInt(fuzkPubKey[0].toString()),
-    BigInt(fuzkPubKey[1].toString()),
-  ])
-}
-
-export function createOrderNoteExt(
-  address: string,
-  asset: string,
-  amount: bigint,
-  feeRatio: bigint,
-  fuzkPubKey: [Fr, Fr]
-): DarkSwapOrderNote {
-  const rho = generateRho()
-  const footer = getNoteFooter(rho, fuzkPubKey)
-
-  const assetMod = encodeAddress(asset)
-  const addressMod = encodeAddress(address)
-  const noteCommitment = mimc_bn254([
-    DOMAIN_ORDER_NOTE,
-    addressMod,
-    assetMod,
-    amount,
-    feeRatio,
-    footer,
-  ])
-
-  return {
-    address,
-    rho,
-    note: noteCommitment,
-    asset,
-    amount,
-    feeRatio,
-  }
-}

package/src/proof/pro/orders/cancelOrderProof.ts

@@ -1,126 +0,0 @@
-import proCancelOrderCircuit from "../../../circuits/pro/dark_swap_cancel_order_compiled_circuit.json";
-import { BaseProofInput, BaseProofParam, BaseProofResult, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, EMPTY_NULLIFIER, PROOF_DOMAIN } from "../../../types";
-import { encodeAddress } from "../../../utils/encoders";
-import { bn_to_0xhex, bn_to_hex } from "../../../utils/formatters";
-import { mimc_bn254 } from "../../../utils/mimc";
-import { uint8ArrayToNumberArray } from "../../../utils/proofUtils";
-import { generateProof, signMessage } from "../../baseProofService";
-import { generateKeyPair } from "../../keyService";
-import { calcNullifier, getNoteFooter } from "../../noteService";
-
-
-type ProCancelOrderProofInput = BaseProofInput & {
-    merkle_root: string,
-    merkle_index: number[],
-    merkle_path: string[],
-    merkle_index_remaining: number[],
-    merkle_path_remaining: string[],
-
-    asset: string,
-
-    //order note
-    order_note: string,
-    order_rho: string,
-    order_nullifier: string,
-    order_amount: string,
-    fee_ratio: string,
-
-    //account remaining note
-    remaining_note: string,
-    remaining_rho: string,
-    remaining_nullifier: string,
-    remaining_amount: string,
-
-    //account available note after cancel
-    account_note: string,
-    account_rho: string,
-    account_note_footer: string,
-}
-
-export type ProCancelOrderProofParam = BaseProofParam & {
-    merkleRoot: string,
-    merkleIndex: number[],
-    merklePath: string[],
-    merkleIndexRemaining: number[],
-    merklePathRemaining: string[],
-    orderNote: DarkSwapOrderNote,
-    oldBalanceNote: DarkSwapNote,
-    newBalanceNote: DarkSwapNote,
-}
-
-export type ProCancelOrderProofResult = BaseProofResult & {
-    orderNullifier: string,
-    oldBalanceNullifier: string,
-    newBalanceNoteFooter: string,
-}
-
-export async function generateProCancelOrderProof(param: ProCancelOrderProofParam): Promise<ProCancelOrderProofResult> {
-    if (param.orderNote.amount <= 0n) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-
-    if (param.oldBalanceNote.amount < 0n) {
-        throw new DarkSwapProofError("Invalid old balance amount");
-    }
-    if (param.newBalanceNote.amount < 0n) {
-        throw new DarkSwapProofError("Invalid new balance amount");
-    }
-
-    if (param.orderNote.amount != param.newBalanceNote.amount - param.oldBalanceNote.amount) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-
-    const [[fuzkPubKeyX, fuzkPubKeyY], fuzkPriKey] = await generateKeyPair(param.signedMessage);
-
-    const orderNullifier = calcNullifier(param.orderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    let oldBalanceNullifier = EMPTY_NULLIFIER;
-    if (param.oldBalanceNote.amount != 0n) {
-        oldBalanceNullifier = calcNullifier(param.oldBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    }
-    const newBalanceNoteFooter = getNoteFooter(param.newBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-
-    const addressMod = encodeAddress(param.address);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.PRO_CANCEL_ORDER),
-        orderNullifier,
-        param.orderNote.feeRatio,
-        oldBalanceNullifier,
-        param.newBalanceNote.note,
-    ]));
-    const signature = await signMessage(message, fuzkPriKey);
-
-    const inputs: ProCancelOrderProofInput = {
-        address: bn_to_0xhex(addressMod),
-        merkle_root: param.merkleRoot,
-        merkle_index: param.merkleIndex,
-        merkle_path: param.merklePath.map((x) => bn_to_0xhex(BigInt(x))),
-        merkle_index_remaining: param.merkleIndexRemaining,
-        merkle_path_remaining: param.merklePathRemaining.map((x) => bn_to_0xhex(BigInt(x))),
-        order_note: bn_to_0xhex(param.orderNote.note),
-        order_rho: bn_to_0xhex(param.orderNote.rho),
-        order_nullifier: bn_to_0xhex(orderNullifier),
-        order_amount: bn_to_0xhex(param.orderNote.amount),
-        fee_ratio: bn_to_0xhex(param.orderNote.feeRatio),
-
-        remaining_note: bn_to_0xhex(param.oldBalanceNote.note),
-        remaining_rho: bn_to_0xhex(param.oldBalanceNote.rho),
-        remaining_nullifier: bn_to_0xhex(oldBalanceNullifier),
-        remaining_amount: bn_to_0xhex(param.oldBalanceNote.amount),
-
-        account_note: bn_to_0xhex(param.newBalanceNote.note),
-        account_rho: bn_to_0xhex(param.newBalanceNote.rho),
-        account_note_footer: bn_to_0xhex(newBalanceNoteFooter),
-
-        asset: bn_to_0xhex(encodeAddress(param.orderNote.asset)),
-
-        pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
-        signature: uint8ArrayToNumberArray(signature),
-    };
-    const proof = await generateProof(proCancelOrderCircuit, inputs);
-    return {
-        ...proof,
-        orderNullifier: inputs.order_nullifier,
-        oldBalanceNullifier: inputs.remaining_nullifier,
-        newBalanceNoteFooter: inputs.account_note_footer,
-    }
-};

package/src/proof/pro/orders/createOrderProof.ts

@@ -1,136 +0,0 @@
-import proCreateOrderCircuit from "../../../circuits/pro/dark_swap_pro_create_order_compiled_circuit.json";
-import { BaseProofInput, BaseProofParam, BaseProofResult, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, EMPTY_FOOTER, FEE_RATIO_PRECISION, PROOF_DOMAIN } from "../../../types";
-import { encodeAddress } from "../../../utils/encoders";
-import { bn_to_0xhex, bn_to_hex } from "../../../utils/formatters";
-import { mimc_bn254 } from "../../../utils/mimc";
-import { uint8ArrayToNumberArray } from "../../../utils/proofUtils";
-import { generateProof, signMessage } from "../../baseProofService";
-import { generateKeyPair } from "../../keyService";
-import { calcNullifier, getNoteFooter } from "../../noteService";
-
-type ProCreateOrderProofInput = BaseProofInput & {
-    merkle_root: string,
-    merkle_index: number[],
-    merkle_path: string[],
-
-    out_note: string,
-    out_rho: string,
-    out_nullifier: string,
-    out_amount: string,
-
-    //fee
-    fee_ratio: string,
-    fee_amount: string,
-
-    //new balance note
-    change_note: string,
-    change_rho: string,
-    change_note_footer: string,
-    change_amount: string,
-
-    //order note swap out
-    order_note: string,
-    order_rho: string,
-    order_note_footer: string,
-
-    //note swap in
-    order_asset: string,
-    order_amount: string,
-    in_asset: string,
-    in_amount: string,
-}
-
-export type ProCreateOrderProofParam = BaseProofParam & {
-    merkleRoot: string,
-    merkleIndex: number[],
-    merklePath: string[],
-    oldBalanceNote: DarkSwapNote,
-    newBalanceNote: DarkSwapNote,
-    orderNote: DarkSwapOrderNote,
-    inAsset: string,
-    inAmount: bigint,
-}
-
-export type ProCreateOrderProofResult = BaseProofResult & {
-    oldBalanceNullifier: string,
-    newBalanceFooter: string,
-    orderNoteFooter: string,
-}
-
-export async function generateProCreateOrderProof(param: ProCreateOrderProofParam): Promise<ProCreateOrderProofResult> {
-    if (param.orderNote.feeRatio < 0n) {
-        throw new DarkSwapProofError("Invalid fee ratio");
-    }
-
-    if (param.newBalanceNote.amount < 0n
-        || param.oldBalanceNote.amount <= 0n
-        || param.inAmount <= 0n
-        || param.orderNote.amount <= 0n) {
-        throw new DarkSwapProofError("Invalid note amount");
-    }
-
-    if (param.orderNote.amount != param.oldBalanceNote.amount - param.newBalanceNote.amount) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-
-    const feeAmount = param.inAmount * param.orderNote.feeRatio / FEE_RATIO_PRECISION;
-
-    const [[fuzkPubKeyX, fuzkPubKeyY], fuzkPriKey] = await generateKeyPair(param.signedMessage);
-
-    let newBalanceFooter = EMPTY_FOOTER;
-    if (param.newBalanceNote.amount != 0n) {
-        newBalanceFooter = getNoteFooter(param.newBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    }
-
-    const oldBalanceNullifier = calcNullifier(param.oldBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const orderNoteFooter = getNoteFooter(param.orderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-
-    const addressMod = encodeAddress(param.address);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.PRO_CREATE_ORDER),
-        oldBalanceNullifier,
-        param.orderNote.feeRatio,
-        param.newBalanceNote.note,
-        param.orderNote.note,
-        encodeAddress(param.inAsset),
-        param.inAmount
-    ]));
-    const signature = await signMessage(message, fuzkPriKey);
-
-    const inputs: ProCreateOrderProofInput = {
-        merkle_root: param.merkleRoot,
-        merkle_index: param.merkleIndex,
-        merkle_path: param.merklePath,
-
-        address: bn_to_0xhex(addressMod),
-        out_note: bn_to_0xhex(param.oldBalanceNote.note),
-        out_rho: bn_to_0xhex(param.oldBalanceNote.rho),
-        out_nullifier: bn_to_0xhex(oldBalanceNullifier),
-        out_amount: bn_to_0xhex(param.oldBalanceNote.amount),
-        fee_ratio: bn_to_0xhex(param.orderNote.feeRatio),
-        fee_amount: bn_to_0xhex(feeAmount),
-
-        change_note: bn_to_0xhex(param.newBalanceNote.note),
-        change_rho: bn_to_0xhex(param.newBalanceNote.rho),
-        change_note_footer: bn_to_0xhex(newBalanceFooter),
-        change_amount: bn_to_0xhex(param.newBalanceNote.amount),
-
-        order_note: bn_to_0xhex(param.orderNote.note),
-        order_rho: bn_to_0xhex(param.orderNote.rho),
-        order_note_footer: bn_to_0xhex(orderNoteFooter),
-        order_asset: bn_to_0xhex(encodeAddress(param.orderNote.asset)),
-        order_amount: bn_to_0xhex(param.orderNote.amount),
-        in_asset: bn_to_0xhex(encodeAddress(param.inAsset)),
-        in_amount: bn_to_0xhex(param.inAmount),
-
-        pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
-        signature: uint8ArrayToNumberArray(signature),
-    };
-    const proof = await generateProof(proCreateOrderCircuit, inputs);
-    return {
-        ...proof,
-        oldBalanceNullifier: inputs.out_nullifier,
-        newBalanceFooter: inputs.change_note_footer,
-        orderNoteFooter: inputs.order_note_footer,
-    }
-};

package/src/proof/pro/orders/swapProof.ts

@@ -1,189 +0,0 @@
-import swapCircuit from "../../../circuits/pro/dark_swap_pro_swap_compiled_circuit.json";
-import { BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, EMPTY_FOOTER, PROOF_DOMAIN } from "../../../types";
-import { encodeAddress } from "../../../utils/encoders";
-import { bn_to_0xhex, bn_to_hex } from "../../../utils/formatters";
-import { mimc_bn254 } from "../../../utils/mimc";
-import { hexStringToSignature, uint8ArrayToNumberArray } from "../../../utils/proofUtils";
-import { generateProof, signMessage } from "../../baseProofService";
-import { generateKeyPair } from "../../keyService";
-import { calcNullifier, getNoteFooter } from "../../noteService";
-
-type ProSwapProofInput = {
-    merkle_root: string,
-
-    // Alice input
-    alice_merkle_index: number[],
-    alice_merkle_path: string[],
-    alice_address: string,
-    alice_out_note: string,
-    alice_out_amount: 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_change_note: string,
-    alice_change_rho: string,
-    alice_change_note_footer: string,
-
-    // Alice pub key and signature
-    alice_pub_key: string[],
-    alice_signature: any,
-
-    //Bob order
-    bob_out_asset: string,
-    bob_out_amount: string,
-    bob_in_asset: string,
-    bob_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 ProSwapProofParam = {
-    merkleRoot: string,
-    aliceMerkleIndex: number[],
-    aliceMerklePath: string[],
-    aliceAddress: string,
-    aliceOrderNote: DarkSwapOrderNote,
-    aliceFeeAmount: bigint,
-    aliceInNote: DarkSwapNote,
-    aliceChangeNote: DarkSwapNote,
-    aliceSignedMessage: string,
-
-    bobMerkleIndex: number[],
-    bobMerklePath: string[],
-    bobAddress: string,
-    bobMessage: DarkSwapMessage,
-}
-
-export type ProSwapProofResult = BaseProofResult & {
-    aliceOutNullifier: string,
-    aliceInNoteFooter: string,
-    aliceChangeNoteFooter: string,
-    bobOutNullifier: string,
-    bobInNoteFooter: string,
-}
-
-export async function generateProSwapProof(param: ProSwapProofParam): Promise<ProSwapProofResult> {
-    if (param.aliceOrderNote.feeRatio < 0n
-        || param.bobMessage.orderNote.feeRatio < 0n) {
-        throw new DarkSwapProofError("Invalid fee ratio");
-    }
-
-    if (param.aliceChangeNote.amount < 0n
-        || param.aliceOrderNote.amount <= 0n
-        || param.aliceInNote.amount <= 0n
-        || param.bobMessage.inNote.amount <= 0n
-        || param.bobMessage.orderNote.amount <= 0n) {
-        throw new DarkSwapProofError("Invalid note amount");
-    }
-
-    if (param.aliceOrderNote.amount != param.aliceChangeNote.amount + param.bobMessage.inNote.amount + param.bobMessage.feeAmount
-        || param.bobMessage.orderNote.amount != param.aliceInNote.amount + param.aliceFeeAmount) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-
-    const [[fuzkPubKeyX, fuzkPubKeyY], fuzkPriKey] = await generateKeyPair(param.aliceSignedMessage);
-
-    const aliceOrderNoteNullifier = calcNullifier(param.aliceOrderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const aliceInNoteFooter = getNoteFooter(param.aliceInNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const aliceChangeNoteFooter = param.aliceChangeNote.amount == 0n ? EMPTY_FOOTER : getNoteFooter(param.aliceChangeNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-    const bobOrderNoteNullifier = calcNullifier(param.bobMessage.orderNote.rho, param.bobMessage.publicKey);
-    const bobInNoteFooter = getNoteFooter(param.bobMessage.inNote.rho, param.bobMessage.publicKey);
-
-    const aliceAddressMod = encodeAddress(param.aliceAddress);
-    const bobAddressMod = encodeAddress(param.bobAddress);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.PRO_SWAP),
-        aliceOrderNoteNullifier,
-        param.aliceOrderNote.feeRatio,
-        param.bobMessage.orderNote.feeRatio,
-        bobOrderNoteNullifier,
-        param.aliceInNote.note,
-        param.aliceChangeNote.note,
-        param.bobMessage.inNote.note
-    ]));
-    const signature = await signMessage(message, fuzkPriKey);
-
-    const inputs: ProSwapProofInput = {
-        merkle_root: param.merkleRoot,
-        alice_merkle_index: param.aliceMerkleIndex,
-        alice_merkle_path: param.aliceMerklePath,
-        alice_address: bn_to_0xhex(aliceAddressMod),
-        alice_out_note: bn_to_0xhex(param.aliceOrderNote.note),
-        alice_out_rho: bn_to_0xhex(param.aliceOrderNote.rho),
-        alice_out_nullifier: bn_to_0xhex(aliceOrderNoteNullifier),
-        alice_out_amount: bn_to_0xhex(param.aliceOrderNote.amount),
-        alice_fee_ratio: bn_to_0xhex(param.aliceOrderNote.feeRatio),
-        alice_fee_amount: bn_to_0xhex(param.aliceFeeAmount),
-
-        alice_in_note: bn_to_0xhex(param.aliceInNote.note),
-        alice_in_rho: bn_to_0xhex(param.aliceInNote.rho),
-        alice_in_note_footer: bn_to_0xhex(aliceInNoteFooter),
-
-        alice_change_note: bn_to_0xhex(param.aliceChangeNote.note),
-        alice_change_rho: bn_to_0xhex(param.aliceChangeNote.rho),
-        alice_change_note_footer: bn_to_0xhex(aliceChangeNoteFooter),
-
-        alice_pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
-        alice_signature: uint8ArrayToNumberArray(signature),
-
-        bob_out_asset: bn_to_0xhex(encodeAddress(param.bobMessage.orderNote.asset)),
-        bob_out_amount: bn_to_0xhex(param.bobMessage.orderNote.amount),
-        bob_in_asset: bn_to_0xhex(encodeAddress(param.bobMessage.inNote.asset)),
-        bob_in_amount: bn_to_0xhex(param.bobMessage.inNote.amount + param.bobMessage.feeAmount),
-
-        bob_merkle_index: param.bobMerkleIndex,
-        bob_merkle_path: param.bobMerklePath,
-        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(param.bobMessage.feeAmount),
-
-        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(swapCircuit, inputs);
-    return {
-        ...proof,
-        aliceOutNullifier: inputs.alice_out_nullifier,
-        aliceInNoteFooter: inputs.alice_in_note_footer,
-        aliceChangeNoteFooter: inputs.alice_change_note_footer,
-        bobOutNullifier: inputs.bob_out_nullifier,
-        bobInNoteFooter: inputs.bob_in_note_footer,
-    }
-};

package/src/proof/retail/cancelOrderProof.ts

@@ -1,78 +0,0 @@
-import retailCancelOrderCircuit from "../../circuits/retail/dark_swap_cancel_order_withdraw_compiled_circuit.json";
-import { BaseProofInput, BaseProofParam, BaseProofResult, DarkSwapOrderNote, DarkSwapProofError, PROOF_DOMAIN } from "../../types";
-import { encodeAddress } from "../../utils/encoders";
-import { bn_to_0xhex, bn_to_hex } from "../../utils/formatters";
-import { mimc_bn254 } from "../../utils/mimc";
-import { uint8ArrayToNumberArray } from "../../utils/proofUtils";
-import { generateProof, signMessage } from "../baseProofService";
-import { generateKeyPair } from "../keyService";
-import { calcNullifier } from "../noteService";
-
-
-type RetailCancelOrderProofInput = BaseProofInput & {
-    merkle_root: string,
-    merkle_index: number[],
-    merkle_path: string[],
-    //order note
-    out_note: string,
-    out_asset: string,
-    out_amount: string,
-    out_rho: string,
-    out_nullifier: string,
-    fee_ratio: string,
-}
-
-export type RetailCancelOrderProofParam = BaseProofParam & {
-    merkleRoot: string,
-    merkleIndex: number[],
-    merklePath: string[],
-    orderNote: DarkSwapOrderNote,
-}
-
-export type RetailCancelOrderProofResult = BaseProofResult & {
-    nullifier: string,
-}
-
-export async function generateRetailCancelOrderProof(param: RetailCancelOrderProofParam): Promise<RetailCancelOrderProofResult> {
-    if (param.orderNote.amount <= 0n) {
-        throw new DarkSwapProofError("Order amount must be greater than 0");
-    }
-
-    if (param.orderNote.feeRatio < 0n) {
-        throw new DarkSwapProofError("Fee ratio must be greater or equal to 0");
-    }
-
-    const [[fuzkPubKeyX, fuzkPubKeyY], fuzkPriKey] = await generateKeyPair(param.signedMessage);
-
-    const nullifier = calcNullifier(param.orderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
-
-    const addressMod = encodeAddress(param.address);
-    const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.RETAIL_CANCEL_ORDER),
-        addressMod,
-        nullifier,
-        param.orderNote.feeRatio,
-    ]));
-    const signature = await signMessage(message, fuzkPriKey);
-
-    const inputs: RetailCancelOrderProofInput = {
-        address: bn_to_0xhex(addressMod),
-        merkle_root: param.merkleRoot,
-        merkle_index: param.merkleIndex,
-        merkle_path: param.merklePath.map((x) => bn_to_0xhex(BigInt(x))),
-        out_note: bn_to_0xhex(param.orderNote.note),
-        out_asset: bn_to_0xhex(encodeAddress(param.orderNote.asset)),
-        out_amount: bn_to_0xhex(param.orderNote.amount),
-        out_rho: bn_to_0xhex(param.orderNote.rho),
-        out_nullifier: bn_to_0xhex(nullifier),
-        fee_ratio: bn_to_0xhex(param.orderNote.feeRatio),
-
-        pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
-        signature: uint8ArrayToNumberArray(signature),
-    };
-    const proof = await generateProof(retailCancelOrderCircuit, inputs);
-    return {
-        ...proof,
-        nullifier: inputs.out_nullifier,
-    }
-};