@thesingularitynetwork/darkswap-sdk 0.1.14 → 0.1.16

package/dist/index.js

@@ -1,8 +1,11 @@
-import { ethers, AbiCoder, ripemd160, hexlify } from 'ethers';
-import { Schnorr } from '@aztec/foundation/crypto';
-import { Fr, Fq } from '@aztec/foundation/fields';
-import { UltraHonkBackend } from '@aztec/bb.js';
-import { Noir } from '@noir-lang/noir_js';
+'use strict';
+
+var ethers = require('ethers');
+var cryptoJs = require('crypto-js');
+var crypto = require('@aztec/foundation/crypto');
+var fields = require('@aztec/foundation/fields');
+var bb_js = require('@aztec/bb.js');
+var noir_js = require('@noir-lang/noir_js');
 
 const NATIVE_ASSETS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
 function isNativeAsset(asset) {
@@ -14,7 +17,7 @@ function isAddressEquals(address1, address2) {
     return address1.toLowerCase() === address2.toLowerCase();
 }
 function hexlify32(value) {
-    return ethers.zeroPadValue(ethers.toBeHex(value), 32);
+    return ethers.ethers.zeroPadValue(ethers.ethers.toBeHex(value), 32);
 }
 function isHexEquals(hex1, hex2) {
     if (!hex1 || !hex2)
@@ -575,22 +578,22 @@ class DarkSwapError extends Error {
     }
 }
 
-var NoteOnChainStatus;
+exports.NoteOnChainStatus = void 0;
 (function (NoteOnChainStatus) {
     NoteOnChainStatus["ACTIVE"] = "ACTIVE";
     NoteOnChainStatus["SPENT"] = "SPENT";
     NoteOnChainStatus["LOCKED"] = "LOCKED";
     NoteOnChainStatus["UNKNOWN"] = "UNKNOWN";
-})(NoteOnChainStatus || (NoteOnChainStatus = {}));
+})(exports.NoteOnChainStatus || (exports.NoteOnChainStatus = {}));
 
 const P = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
 const MAX_ALLOWANCE = BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935'); // 2**256 - 1
 
-const defaultAbiCoder = new AbiCoder();
+const defaultAbiCoder = new ethers.AbiCoder();
 function encodeAddress(address) {
     let encoder = defaultAbiCoder;
     let encodedAddress = encoder.encode(["address"], [address]);
-    let hashedAddress = ripemd160(encodedAddress);
+    let hashedAddress = ethers.ripemd160(encodedAddress);
     return BigInt(hashedAddress);
 }
 
@@ -731,13 +734,14 @@ function mimc_bn254(array) {
 }
 
 let getRandomValues;
-if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+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);
+        const randomBytes = cryptoJs.randomBytes(buf.length);
         buf.set(randomBytes);
         return buf;
     };
@@ -748,30 +752,28 @@ const EMPTY_NOTE = {
     rho: 0n,
     note: 0n,
     amount: 0n,
-    asset: '0x0000000000000000000000000000000000000000'
+    asset: '0x0000000000000000000000000000000000000000',
 };
 function createNote(address, asset, amount, fuzkPubKey) {
     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
-    ]);
+    const note = mimc_bn254([DOMAIN_NOTE, addressMod, assetMod, amount, footer]);
     return {
         rho,
         note,
         asset,
         amount,
-        footer
+        footer,
     };
 }
 function getNoteFooter(rho, publicKey) {
-    return mimc_bn254([mimc_bn254([BigInt(rho)]), BigInt(publicKey[0].toString()), BigInt(publicKey[1].toString())]);
+    return mimc_bn254([
+        mimc_bn254([BigInt(rho)]),
+        BigInt(publicKey[0].toString()),
+        BigInt(publicKey[1].toString()),
+    ]);
 }
 function generateRho() {
     const securityLevel = 128;
@@ -781,12 +783,16 @@ function generateRho() {
     do {
         let ab = new ArrayBuffer(totalBytes);
         let buf = new Uint8Array(ab);
-        rho = BigInt(hexlify(getRandomValues(buf))) % P;
+        rho = BigInt(ethers.hexlify(getRandomValues(buf))) % P;
     } while (rho === BigInt(0));
     return rho;
 }
 function calcNullifier(rho, fuzkPubKey) {
-    return mimc_bn254([rho, BigInt(fuzkPubKey[0].toString()), BigInt(fuzkPubKey[1].toString())]);
+    return mimc_bn254([
+        rho,
+        BigInt(fuzkPubKey[0].toString()),
+        BigInt(fuzkPubKey[1].toString()),
+    ]);
 }
 function createOrderNoteExt(address, asset, amount, feeRatio, fuzkPubKey) {
     const rho = generateRho();
@@ -799,43 +805,43 @@ function createOrderNoteExt(address, asset, amount, feeRatio, fuzkPubKey) {
         assetMod,
         amount,
         feeRatio,
-        footer
+        footer,
     ]);
     return {
         rho,
         note: noteCommitment,
         asset,
         amount,
-        feeRatio
+        feeRatio,
     };
 }
 
 async function generateKeyPair(signature) {
-    const privateKey = Fr.fromBufferReduce(Buffer.from(signature.replace("0x", ""), "hex"));
-    const schnorr = new Schnorr();
-    const publicKey = await schnorr.computePublicKey(Fq.fromBufferReduce(privateKey.toBuffer()));
+    const privateKey = fields.Fr.fromBufferReduce(Buffer.from(signature.replace("0x", ""), "hex"));
+    const schnorr = new crypto.Schnorr();
+    const publicKey = await schnorr.computePublicKey(fields.Fq.fromBufferReduce(privateKey.toBuffer()));
     return [[publicKey.x, publicKey.y], privateKey];
 }
 
 function getContract$2(address, darkSwap) {
     const provider = darkSwap.provider;
-    return new ethers.Contract(address, MerkleAbi.abi, provider);
+    return new ethers.ethers.Contract(address, MerkleAbi.abi, provider);
 }
 async function getNoteOnChainStatus(darkSwap, note, nullifier) {
     const contract = getContract$2(darkSwap.contracts.merkleTreeOperator, darkSwap);
     const isCreated = (await contract.noteCommitmentsCreated(note));
     if (!isCreated) {
-        return NoteOnChainStatus.UNKNOWN;
+        return exports.NoteOnChainStatus.UNKNOWN;
     }
     const isSpent = (await contract.nullifiersUsed(nullifier));
     if (isSpent) {
-        return NoteOnChainStatus.SPENT;
+        return exports.NoteOnChainStatus.SPENT;
     }
     const isLocked = (await contract.nullifiersLocked(nullifier));
     if (isLocked) {
-        return NoteOnChainStatus.LOCKED;
+        return exports.NoteOnChainStatus.LOCKED;
     }
-    return NoteOnChainStatus.ACTIVE;
+    return exports.NoteOnChainStatus.ACTIVE;
 }
 async function getNoteOnChainStatusByPublicKey(darkSwap, note, publicKey) {
     const nullifier = calcNullifier(note.rho, publicKey);
@@ -851,17 +857,17 @@ async function getNoteOnChainStatusBySignature(darkSwap, note, signature) {
 async function isNoteActive(darkSwap, note, publicKey) {
     const nullifier = calcNullifier(note.rho, publicKey);
     const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-    return onChainStatus === NoteOnChainStatus.ACTIVE;
+    return onChainStatus === exports.NoteOnChainStatus.ACTIVE;
 }
 async function isNoteSpent(darkSwap, note, publicKey) {
     const nullifier = calcNullifier(note.rho, publicKey);
     const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-    return onChainStatus === NoteOnChainStatus.SPENT;
+    return onChainStatus === exports.NoteOnChainStatus.SPENT;
 }
 async function isNoteValid(darkSwap, note, publicKey) {
     const nullifier = calcNullifier(note.rho, publicKey);
     const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-    return onChainStatus === NoteOnChainStatus.ACTIVE;
+    return onChainStatus === exports.NoteOnChainStatus.ACTIVE;
 }
 async function getNullifierBySignature(note, signature) {
     const [publicKey] = await generateKeyPair(signature);
@@ -2434,7 +2440,7 @@ var abi$b = [
 var ERC20_USDT = {
 	abi: abi$b};
 
-var ChainId;
+exports.ChainId = void 0;
 (function (ChainId) {
     ChainId[ChainId["HARDHAT"] = 31337] = "HARDHAT";
     ChainId[ChainId["HARDHAT_ARBITRUM"] = 31338] = "HARDHAT_ARBITRUM";
@@ -2443,11 +2449,11 @@ var ChainId;
     ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
     ChainId[ChainId["ARBITRUM_ONE"] = 42161] = "ARBITRUM_ONE";
     ChainId[ChainId["BASE"] = 8453] = "BASE";
-})(ChainId || (ChainId = {}));
+})(exports.ChainId || (exports.ChainId = {}));
 
 const legacyTokenConfig = {
-    [ChainId.MAINNET]: ['0xdac17f958d2ee523a2206206994597c13d831ec7'],
-    [ChainId.HARDHAT]: ['0xdac17f958d2ee523a2206206994597c13d831ec7']
+    [exports.ChainId.MAINNET]: ['0xdac17f958d2ee523a2206206994597c13d831ec7'],
+    [exports.ChainId.HARDHAT]: ['0xdac17f958d2ee523a2206206994597c13d831ec7']
 };
 const DEFAULT_FEE_RATIO = 300n;
 
@@ -2656,7 +2662,7 @@ var depositCircuit = {
 	brillig_names: brillig_names$9
 };
 
-var PROOF_DOMAIN;
+exports.PROOF_DOMAIN = void 0;
 (function (PROOF_DOMAIN) {
     PROOF_DOMAIN[PROOF_DOMAIN["DEPOSIT"] = 10001] = "DEPOSIT";
     PROOF_DOMAIN[PROOF_DOMAIN["WITHDRAW"] = 10002] = "WITHDRAW";
@@ -2668,7 +2674,7 @@ var PROOF_DOMAIN;
     PROOF_DOMAIN[PROOF_DOMAIN["JOIN"] = 10008] = "JOIN";
     PROOF_DOMAIN[PROOF_DOMAIN["TRIPLE_JOIN"] = 10009] = "TRIPLE_JOIN";
     PROOF_DOMAIN[PROOF_DOMAIN["RETAIL_SWAP"] = 10010] = "RETAIL_SWAP";
-})(PROOF_DOMAIN || (PROOF_DOMAIN = {}));
+})(exports.PROOF_DOMAIN || (exports.PROOF_DOMAIN = {}));
 const EMPTY_NULLIFIER = 0n;
 const EMPTY_FOOTER = 0n;
 const FEE_RATIO_PRECISION = 1000000n;
@@ -2699,13 +2705,13 @@ function uint8ArrayToNumberArray(uint8Array) {
 
 async function generateProof(circuit, inputs) {
     const start_time = new Date().getTime();
-    const backend = new UltraHonkBackend(circuit.bytecode);
-    const noir = new Noir(circuit);
+    const backend = new bb_js.UltraHonkBackend(circuit.bytecode);
+    const noir = new noir_js.Noir(circuit);
     try {
         const { witness } = await noir.execute(inputs);
         const proof = await backend.generateProof(witness, { keccak: true });
         console.log("Proof generated in " + (new Date().getTime() - start_time) + "ms");
-        return { proof: hexlify(proof.proof), verifyInputs: proof.publicInputs };
+        return { proof: ethers.hexlify(proof.proof), verifyInputs: proof.publicInputs };
     }
     finally {
         const destroy_start_time = new Date().getTime();
@@ -2714,8 +2720,8 @@ async function generateProof(circuit, inputs) {
     }
 }
 async function signMessage(message, fuzkPriKey) {
-    const schnorr = new Schnorr();
-    const signature = await schnorr.constructSignature(Buffer.from(message, "hex").reverse(), Fq.fromBufferReduce(fuzkPriKey.toBuffer()));
+    const schnorr = new crypto.Schnorr();
+    const signature = await schnorr.constructSignature(Buffer.from(message, "hex").reverse(), fields.Fq.fromBufferReduce(fuzkPriKey.toBuffer()));
     return signature.toBuffer();
 }
 
@@ -2735,7 +2741,7 @@ async function generateDepositProof(param) {
     const newBalanceFooter = getNoteFooter(param.newBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
     const addressMod = encodeAddress(param.address);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.DEPOSIT),
+        BigInt(exports.PROOF_DOMAIN.DEPOSIT),
         oldBalanceNullifier,
         addressMod,
         param.newBalanceNote.note,
@@ -2836,7 +2842,7 @@ const EMPTY_PATH = {
 };
 function getContract$1(address, darkSwap) {
     const provider = darkSwap.provider;
-    return new ethers.Contract(address, MerkleAbi.abi, provider);
+    return new ethers.ethers.Contract(address, MerkleAbi.abi, provider);
 }
 async function getMerklePathAndRoot(note, darkSwap) {
     const result = await multiGetMerklePathAndRoot([note], darkSwap);
@@ -2956,7 +2962,7 @@ class DepositService extends BaseContractService {
             throw new DarkSwapError('Invalid context');
         }
         const signer = this._darkSwap.signer;
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, signer);
+        const contract = new ethers.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 });
@@ -2974,12 +2980,12 @@ class DepositService extends BaseContractService {
             throw new DarkSwapError('Invalid context');
         }
         const signer = this._darkSwap.signer;
-        const allowanceContract = new ethers.Contract(context.newBalance.asset, ERC20Abi.abi, this._darkSwap);
+        const allowanceContract = new ethers.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 contract = new ethers.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();
         }
@@ -3208,7 +3214,7 @@ async function generateWithdrawProof(param) {
     const addressMod = encodeAddress(param.address);
     const assetMod = encodeAddress(param.oldBalance.asset);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.WITHDRAW),
+        BigInt(exports.PROOF_DOMAIN.WITHDRAW),
         addressMod,
         oldBalanceNullifier,
         param.newBalance.note,
@@ -3328,7 +3334,7 @@ class WithdrawService extends BaseContractService {
         if (!context || !context.currentBalance || !context.newBalance || !context.proof || !context.merkleRoot) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.withdraw(context.merkleRoot, context.currentBalance.asset, context.withdrawAmount, context.proof.oldBalanceNullifier, hexlify32(context.newBalance.note), context.proof.newBalanceFooter, context.proof.proof);
         await tx.wait();
         return tx.hash;
@@ -3601,7 +3607,7 @@ async function generateJoinProof(param) {
     const outNoteFooter = getNoteFooter(param.outNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
     const addressMod = encodeAddress(param.address);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.JOIN),
+        BigInt(exports.PROOF_DOMAIN.JOIN),
         inNullifier1,
         inNullifier2,
         param.outNote.note,
@@ -3738,7 +3744,7 @@ class JoinService extends BaseContractService {
         if (!context || !context.inNote1 || !context.inNote2 || !context.outNote || !context.proof || !context.merkleRoot) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.join(context.merkleRoot, [
             context.proof.inNullifier1,
             context.proof.inNullifier2,
@@ -4070,7 +4076,7 @@ async function generateTripleJoinProof(param) {
     const outNoteFooter = getNoteFooter(param.outNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
     const addressMod = encodeAddress(param.address);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.TRIPLE_JOIN),
+        BigInt(exports.PROOF_DOMAIN.TRIPLE_JOIN),
         inNullifier1,
         inNullifier2,
         inNullifier3,
@@ -4243,7 +4249,7 @@ class TripleJoinService extends BaseContractService {
             || !context.merkleRoot) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.join(context.merkleRoot, [
             context.proof.inNullifier1,
             context.proof.inNullifier2,
@@ -4537,7 +4543,7 @@ async function generateProCreateOrderProof(param) {
     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),
+        BigInt(exports.PROOF_DOMAIN.PRO_CREATE_ORDER),
         oldBalanceNullifier,
         param.orderNote.feeRatio,
         param.newBalanceNote.note,
@@ -4867,7 +4873,7 @@ var DarkSwapFeeAssetManagerAbi = {
 
 function getContract(address, darkSwap) {
     const provider = darkSwap.provider;
-    return new ethers.Contract(address, DarkSwapFeeAssetManagerAbi.abi, provider);
+    return new ethers.ethers.Contract(address, DarkSwapFeeAssetManagerAbi.abi, provider);
 }
 async function getFeeRatio(wallet, darkSwap) {
     const contract = getContract(darkSwap.contracts.darkSwapFeeAssetManager, darkSwap);
@@ -5032,7 +5038,7 @@ class ProCreateOrderService extends BaseContractService {
             || !context.proof) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.proCreateOrder([
             context.merkleRoot,
             context.proof.oldBalanceNullifier,
@@ -5325,7 +5331,7 @@ async function generateProCancelOrderProof(param) {
     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),
+        BigInt(exports.PROOF_DOMAIN.PRO_CANCEL_ORDER),
         orderNullifier,
         param.orderNote.feeRatio,
         oldBalanceNullifier,
@@ -5477,7 +5483,7 @@ class ProCancelOrderService extends BaseContractService {
             || !context.merkleRoot) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.cancelOrder(context.merkleRoot, context.proof.orderNullifier, context.proof.oldBalanceNullifier, hexlify32(context.newBalance.note), context.proof.newBalanceNoteFooter, context.proof.proof);
         await tx.wait();
         return tx.hash;
@@ -5874,7 +5880,7 @@ async function generateProSwapProof(param) {
     const aliceAddressMod = encodeAddress(param.aliceAddress);
     const bobAddressMod = encodeAddress(param.bobAddress);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.PRO_SWAP),
+        BigInt(exports.PROOF_DOMAIN.PRO_SWAP),
         aliceOrderNoteNullifier,
         param.aliceOrderNote.feeRatio,
         param.bobMessage.orderNote.feeRatio,
@@ -6131,7 +6137,7 @@ async function generateRetailSwapMessage(address, orderNote, swapInNote, feeAmou
     const addressMod = encodeAddress(address);
     const orderNoteNullifier = calcNullifier(orderNote.rho, pubKey);
     const message = bn_to_hex(mimc_bn254([
-        BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
+        BigInt(exports.PROOF_DOMAIN.RETAIL_CREATE_ORDER),
         addressMod,
         orderNoteNullifier,
         orderNote.feeRatio,
@@ -6162,7 +6168,7 @@ async function generateRetailCreateOrderProof(param) {
     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),
+        BigInt(exports.PROOF_DOMAIN.RETAIL_CREATE_ORDER),
         addressMod,
         param.depositNote.note,
         param.depositNote.feeRatio,
@@ -6356,7 +6362,7 @@ class ProSwapService extends BaseContractService {
             || !context.bobAddress) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.proSwap([
             context.merkleRoot,
             context.proof.aliceOutNullifier,
@@ -6569,7 +6575,7 @@ async function generateRetailCancelOrderProof(param) {
     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),
+        BigInt(exports.PROOF_DOMAIN.RETAIL_CANCEL_ORDER),
         addressMod,
         nullifier,
         param.orderNote.feeRatio,
@@ -6659,7 +6665,7 @@ class RetailCancelOrderService extends BaseContractService {
         if (!context || !context.orderNote || !context.proof) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.cancelOrderWithdraw(context.merkleRoot, context.orderNote.asset, hexlify32(context.orderNote.amount), context.proof.nullifier, context.proof.proof);
         await tx.wait();
         return tx.hash;
@@ -6774,7 +6780,7 @@ class RetailCreateOrderService extends BaseContractService {
         if (!context || !context.orderNote || !context.swapInNote || !context.proof) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         let ethAmount = 0n;
         if (isNativeAsset(context.orderNote.asset)) {
             ethAmount = context.orderNote.amount;
@@ -7279,7 +7285,7 @@ class RetailSwapService extends BaseContractService {
             || !context.proof) {
             throw new DarkSwapError('Invalid context');
         }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const contract = new ethers.ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
         const tx = await contract.retailSwap([
             context.merkleRoot,
             hexlify32(context.aliceSwapMessage.orderNote.feeRatio),
@@ -7297,7 +7303,7 @@ class RetailSwapService extends BaseContractService {
 }
 
 const contractConfig = {
-    [ChainId.MAINNET]: {
+    [exports.ChainId.MAINNET]: {
         priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
         ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
         nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
@@ -7306,7 +7312,7 @@ const contractConfig = {
         darkSwapFeeAssetManager: '0x0', //FIXME
         drakSwapSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-subgraph/version/v0.0.1/api',
     },
-    [ChainId.ARBITRUM_ONE]: {
+    [exports.ChainId.ARBITRUM_ONE]: {
         priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
         ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
         nativeWrapper: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
@@ -7315,7 +7321,7 @@ const contractConfig = {
         darkSwapFeeAssetManager: '0x0', //FIXME
         drakSwapSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-arb-subgraph/api'
     },
-    [ChainId.BASE]: {
+    [exports.ChainId.BASE]: {
         priceOracle: '0xf224a25453D76A41c4427DD1C05369BC9f498444',
         ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
         nativeWrapper: '0x4200000000000000000000000000000000000006',
@@ -7324,7 +7330,7 @@ const contractConfig = {
         darkSwapFeeAssetManager: '0x0', //FIXME
         drakSwapSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-base-subgraph/api'
     },
-    [ChainId.SEPOLIA]: {
+    [exports.ChainId.SEPOLIA]: {
         priceOracle: '0x4Fe44a9aC8Ef059Be2dB97f9e3bcA32Ab698C2f2',
         ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
         nativeWrapper: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
@@ -7333,7 +7339,7 @@ const contractConfig = {
         darkSwapFeeAssetManager: '0x0', //FIXME
         drakSwapSubgraphUrl: ''
     },
-    [ChainId.HARDHAT]: {
+    [exports.ChainId.HARDHAT]: {
         priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
         ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
         nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
@@ -7412,7 +7418,7 @@ function serializeDarkSwapMessage(swapMessage) {
     });
 }
 function deserializePublicKey(publicKeyString) {
-    return [Fr.fromHexString(publicKeyString[0]), Fr.fromHexString(publicKeyString[1])];
+    return [fields.Fr.fromHexString(publicKeyString[0]), fields.Fr.fromHexString(publicKeyString[1])];
 }
 function deserializeDarkSwapMessage(serializedMessage) {
     const message = JSON.parse(serializedMessage);
@@ -7438,5 +7444,48 @@ function deserializeDarkSwapMessage(serializedMessage) {
     };
 }
 
-export { ChainId, DEFAULT_FEE_RATIO, DOMAIN_NOTE, DOMAIN_ORDER_NOTE, DarkSwap, DarkSwapError, DarkSwapProofError, DepositContext, DepositService, EMPTY_FOOTER, EMPTY_NOTE, EMPTY_NULLIFIER, EMPTY_PATH, FEE_RATIO_PRECISION, JoinService, NoteOnChainStatus, PROOF_DOMAIN, ProCancelOrderService, ProCreateOrderService, ProSwapService, RetailCancelOrderService, RetailCreateOrderService, RetailSwapService, TripleJoinService, WithdrawService, calcNullifier, contractConfig, createNote, createOrderNoteExt, deserializeDarkSwapMessage, generateKeyPair, getFeeRatio, getMerklePathAndRoot, getNoteFooter, getNoteOnChainStatusByPublicKey, getNoteOnChainStatusBySignature, getNullifierBySignature, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, legacyTokenConfig, multiGetMerklePathAndRoot, serializeDarkSwapMessage };
+exports.DEFAULT_FEE_RATIO = DEFAULT_FEE_RATIO;
+exports.DOMAIN_NOTE = DOMAIN_NOTE;
+exports.DOMAIN_ORDER_NOTE = DOMAIN_ORDER_NOTE;
+exports.DarkSwap = DarkSwap;
+exports.DarkSwapError = DarkSwapError;
+exports.DarkSwapProofError = DarkSwapProofError;
+exports.DepositContext = DepositContext;
+exports.DepositService = DepositService;
+exports.EMPTY_FOOTER = EMPTY_FOOTER;
+exports.EMPTY_NOTE = EMPTY_NOTE;
+exports.EMPTY_NULLIFIER = EMPTY_NULLIFIER;
+exports.EMPTY_PATH = EMPTY_PATH;
+exports.FEE_RATIO_PRECISION = FEE_RATIO_PRECISION;
+exports.JoinService = JoinService;
+exports.ProCancelOrderService = ProCancelOrderService;
+exports.ProCreateOrderService = ProCreateOrderService;
+exports.ProSwapService = ProSwapService;
+exports.RetailCancelOrderService = RetailCancelOrderService;
+exports.RetailCreateOrderService = RetailCreateOrderService;
+exports.RetailSwapService = RetailSwapService;
+exports.TripleJoinService = TripleJoinService;
+exports.WithdrawService = WithdrawService;
+exports.calcNullifier = calcNullifier;
+exports.contractConfig = contractConfig;
+exports.createNote = createNote;
+exports.createOrderNoteExt = createOrderNoteExt;
+exports.deserializeDarkSwapMessage = deserializeDarkSwapMessage;
+exports.generateKeyPair = generateKeyPair;
+exports.getFeeRatio = getFeeRatio;
+exports.getMerklePathAndRoot = getMerklePathAndRoot;
+exports.getNoteFooter = getNoteFooter;
+exports.getNoteOnChainStatusByPublicKey = getNoteOnChainStatusByPublicKey;
+exports.getNoteOnChainStatusBySignature = getNoteOnChainStatusBySignature;
+exports.getNullifierBySignature = getNullifierBySignature;
+exports.hexlify32 = hexlify32;
+exports.isAddressEquals = isAddressEquals;
+exports.isHexEquals = isHexEquals;
+exports.isNativeAsset = isNativeAsset;
+exports.isNoteActive = isNoteActive;
+exports.isNoteSpent = isNoteSpent;
+exports.isNoteValid = isNoteValid;
+exports.legacyTokenConfig = legacyTokenConfig;
+exports.multiGetMerklePathAndRoot = multiGetMerklePathAndRoot;
+exports.serializeDarkSwapMessage = serializeDarkSwapMessage;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/src/proof/noteService.d.ts

@@ -1,5 +1,5 @@
-import { Fr } from "@aztec/foundation/fields";
-import { DarkSwapNote, DarkSwapNoteExt, DarkSwapOrderNote } from "../types.js";
+import { Fr } from '@aztec/foundation/fields';
+import { DarkSwapNote, DarkSwapNoteExt, DarkSwapOrderNote } from '../types.js';
 export declare const DOMAIN_NOTE = 2n;
 export declare const DOMAIN_ORDER_NOTE = 3n;
 export declare const EMPTY_NOTE: DarkSwapNote;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thesingularitynetwork/darkswap-sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "DarkSwap SDK for browser and Node.js",
   "type": "module",
   "types": "dist/types/src/index.d.ts",
@@ -49,6 +49,7 @@
     "@noir-lang/noir_js": "^1.0.0-beta.3",
     "@noir-lang/noir_wasm": "^1.0.0-beta.3",
     "@noir-lang/types": "^1.0.0-beta.3",
+    "crypto-js": "^4.2.0",
     "ethers": "^6.14.3"
   }
 }