@thesingularitynetwork/darkswap-sdk 0.1.11 → 0.1.13

package/dist/index.esm.js

@@ -744,6 +744,12 @@ else {
 }
 const DOMAIN_NOTE = 2n;
 const DOMAIN_ORDER_NOTE = 3n;
+const EMPTY_NOTE = {
+    rho: 0n,
+    note: 0n,
+    amount: 0n,
+    asset: '0x0000000000000000000000000000000000000000'
+};
 function createNote(address, asset, amount, fuzkPubKey) {
     const rho = generateRho();
     const footer = getNoteFooter(rho, fuzkPubKey);
@@ -4247,367 +4253,73 @@ class TripleJoinService extends BaseContractService {
     }
 }
 
-var abi$5 = [
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "assetPoolERC20",
-				type: "address"
+var noir_version$4 = "1.0.0-beta.6+e796dfd67726cbc28eb9991782533b211025928d";
+var hash$4 = "3522014172221315185";
+var abi$5 = {
+	parameters: [
+		{
+			name: "merkle_root",
+			type: {
+				kind: "field"
 			},
-			{
-				internalType: "address",
-				name: "assetPoolETH",
-				type: "address"
+			visibility: "public"
+		},
+		{
+			name: "merkle_index",
+			type: {
+				kind: "array",
+				length: 32,
+				type: {
+					kind: "integer",
+					sign: "unsigned",
+					width: 1
+				}
 			},
-			{
-				internalType: "address",
-				name: "initialOwner",
-				type: "address"
-			}
-		],
-		stateMutability: "nonpayable",
-		type: "constructor"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
-		],
-		name: "OwnableInvalidOwner",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "account",
-				type: "address"
-			}
-		],
-		name: "OwnableUnauthorizedAccount",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "token",
-				type: "address"
-			}
-		],
-		name: "SafeERC20FailedOperation",
-		type: "error"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: true,
-				internalType: "address",
-				name: "previousOwner",
-				type: "address"
+			visibility: "private"
+		},
+		{
+			name: "merkle_path",
+			type: {
+				kind: "array",
+				length: 32,
+				type: {
+					kind: "field"
+				}
 			},
-			{
-				indexed: true,
-				internalType: "address",
-				name: "newOwner",
-				type: "address"
-			}
-		],
-		name: "OwnershipTransferred",
-		type: "event"
-	},
-	{
-		stateMutability: "payable",
-		type: "fallback"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "_wallet",
-				type: "address"
+			visibility: "private"
+		},
+		{
+			name: "address",
+			type: {
+				kind: "field"
 			},
-			{
-				internalType: "uint8",
-				name: "level",
-				type: "uint8"
-			}
-		],
-		name: "addMarketMaker",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "wallet",
-				type: "address"
+			visibility: "public"
+		},
+		{
+			name: "out_note",
+			type: {
+				kind: "field"
 			},
-			{
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			}
-		],
-		name: "calculateFee",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
+			visibility: "private"
+		},
+		{
+			name: "out_rho",
+			type: {
+				kind: "field"
 			},
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "asset",
-				type: "address"
+			visibility: "private"
+		},
+		{
+			name: "out_nullifier",
+			type: {
+				kind: "field"
 			},
-			{
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			}
-		],
-		name: "claimFee",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "_wallet",
-				type: "address"
-			}
-		],
-		name: "getMaketMakerRegistration",
-		outputs: [
-			{
-				internalType: "uint8",
-				name: "",
-				type: "uint8"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "wallet",
-				type: "address"
-			}
-		],
-		name: "getServiceFeePercentage",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-		],
-		name: "owner",
-		outputs: [
-			{
-				internalType: "address",
-				name: "",
-				type: "address"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "asset",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "to",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			}
-		],
-		name: "releaseFee",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "_wallet",
-				type: "address"
-			}
-		],
-		name: "removeMarketMaker",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-		],
-		name: "renounceOwnership",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "uint8",
-				name: "level",
-				type: "uint8"
-			},
-			{
-				internalType: "uint256",
-				name: "feePercent",
-				type: "uint256"
-			}
-		],
-		name: "setServiceFeePercent",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "newOwner",
-				type: "address"
-			}
-		],
-		name: "transferOwnership",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		stateMutability: "payable",
-		type: "receive"
-	}
-];
-var DarkSwapFeeAssetManagerAbi = {
-	abi: abi$5};
-
-function getContract(address, darkSwap) {
-    const provider = darkSwap.provider;
-    return new ethers.Contract(address, DarkSwapFeeAssetManagerAbi.abi, provider);
-}
-async function getFeeRatio(wallet, darkSwap) {
-    const contract = getContract(darkSwap.contracts.darkSwapFeeAssetManager, darkSwap);
-    return await contract.getServiceFeePercentage(wallet);
-}
-
-var noir_version$4 = "1.0.0-beta.6+e796dfd67726cbc28eb9991782533b211025928d";
-var hash$4 = "3522014172221315185";
-var abi$4 = {
-	parameters: [
-		{
-			name: "merkle_root",
-			type: {
-				kind: "field"
-			},
-			visibility: "public"
-		},
-		{
-			name: "merkle_index",
-			type: {
-				kind: "array",
-				length: 32,
-				type: {
-					kind: "integer",
-					sign: "unsigned",
-					width: 1
-				}
-			},
-			visibility: "private"
-		},
-		{
-			name: "merkle_path",
-			type: {
-				kind: "array",
-				length: 32,
-				type: {
-					kind: "field"
-				}
-			},
-			visibility: "private"
-		},
-		{
-			name: "address",
-			type: {
-				kind: "field"
-			},
-			visibility: "public"
-		},
-		{
-			name: "out_note",
-			type: {
-				kind: "field"
-			},
-			visibility: "private"
-		},
-		{
-			name: "out_rho",
-			type: {
-				kind: "field"
-			},
-			visibility: "private"
-		},
-		{
-			name: "out_nullifier",
-			type: {
-				kind: "field"
-			},
-			visibility: "public"
-		},
-		{
-			name: "out_amount",
-			type: {
-				kind: "field"
+			visibility: "public"
+		},
+		{
+			name: "out_amount",
+			type: {
+				kind: "field"
 			},
 			visibility: "private"
 		},
@@ -4794,7 +4506,7 @@ var brillig_names$4 = [
 var proCreateOrderCircuit = {
 	noir_version: noir_version$4,
 	hash: hash$4,
-	abi: abi$4,
+	abi: abi$5,
 	bytecode: bytecode$4,
 	debug_symbols: debug_symbols$4,
 	file_map: file_map$4,
@@ -4868,6 +4580,300 @@ async function generateProCreateOrderProof(param) {
     };
 }
 
+var abi$4 = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolERC20",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "assetPoolETH",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "initialOwner",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "OwnableInvalidOwner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "OwnableUnauthorizedAccount",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "token",
+				type: "address"
+			}
+		],
+		name: "SafeERC20FailedOperation",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferred",
+		type: "event"
+	},
+	{
+		stateMutability: "payable",
+		type: "fallback"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_wallet",
+				type: "address"
+			},
+			{
+				internalType: "uint8",
+				name: "level",
+				type: "uint8"
+			}
+		],
+		name: "addMarketMaker",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "wallet",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "calculateFee",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "claimFee",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_wallet",
+				type: "address"
+			}
+		],
+		name: "getMaketMakerRegistration",
+		outputs: [
+			{
+				internalType: "uint8",
+				name: "",
+				type: "uint8"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "wallet",
+				type: "address"
+			}
+		],
+		name: "getServiceFeePercentage",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "releaseFee",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_wallet",
+				type: "address"
+			}
+		],
+		name: "removeMarketMaker",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "renounceOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint8",
+				name: "level",
+				type: "uint8"
+			},
+			{
+				internalType: "uint256",
+				name: "feePercent",
+				type: "uint256"
+			}
+		],
+		name: "setServiceFeePercent",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		stateMutability: "payable",
+		type: "receive"
+	}
+];
+var DarkSwapFeeAssetManagerAbi = {
+	abi: abi$4};
+
+function getContract(address, darkSwap) {
+    const provider = darkSwap.provider;
+    return new ethers.Contract(address, DarkSwapFeeAssetManagerAbi.abi, provider);
+}
+async function getFeeRatio(wallet, darkSwap) {
+    const contract = getContract(darkSwap.contracts.darkSwapFeeAssetManager, darkSwap);
+    return await contract.getServiceFeePercentage(wallet);
+}
+
 class ProCreateOrderContext extends BaseContext {
     constructor(signature) {
         super(signature);
@@ -5472,7 +5478,7 @@ class ProCancelOrderService extends BaseContractService {
             throw new DarkSwapError('Invalid context');
         }
         const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
-        const tx = await contract.proCancelOrder(context.merkleRoot, context.proof.orderNullifier, context.proof.oldBalanceNullifier, hexlify32(context.newBalance.note), context.proof.newBalanceNoteFooter, context.proof.proof);
+        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;
     }
@@ -5827,247 +5833,103 @@ var brillig_names$2 = [
 	"decompose_hint",
 	"lte_hint",
 	"__get_quotient",
-	"__gt",
-	"directive_invert",
-	"directive_to_radix",
-	"directive_integer_quotient"
-];
-var swapCircuit = {
-	noir_version: noir_version$2,
-	hash: hash$2,
-	abi: abi$2,
-	bytecode: bytecode$2,
-	debug_symbols: debug_symbols$2,
-	file_map: file_map$2,
-	names: names$2,
-	brillig_names: brillig_names$2
-};
-
-async function generateProSwapProof(param) {
-    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.orderNote.amount != param.aliceInNote.amount) {
-        throw new DarkSwapProofError("Invalid order amount");
-    }
-    const aliceFeeAmount = param.aliceInNote.amount * param.aliceOrderNote.feeRatio / FEE_RATIO_PRECISION;
-    const bobFeeAmount = param.bobMessage.inNote.amount * param.bobMessage.orderNote.feeRatio / FEE_RATIO_PRECISION;
-    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 = 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 = {
-        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(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),
-        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(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(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,
-    };
-}
-
-class ProSwapContext extends BaseContext {
-    constructor(signature) {
-        super(signature);
-        Object.defineProperty(this, "_orderNote", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_changeNote", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_swapInNote", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_proof", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_bobAddress", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_bobSwapMessage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    set orderNote(orderNote) {
-        this._orderNote = orderNote;
-    }
-    get orderNote() {
-        return this._orderNote;
-    }
-    set changeNote(changeNote) {
-        this._changeNote = changeNote;
-    }
-    get changeNote() {
-        return this._changeNote;
-    }
-    set swapInNote(swapInNote) {
-        this._swapInNote = swapInNote;
-    }
-    get swapInNote() {
-        return this._swapInNote;
-    }
-    set proof(proof) {
-        this._proof = proof;
-    }
-    get proof() {
-        return this._proof;
-    }
-    set bobSwapMessage(bobSwapMessage) {
-        this._bobSwapMessage = bobSwapMessage;
-    }
-    get bobSwapMessage() {
-        return this._bobSwapMessage;
-    }
-    set bobAddress(bobAddress) {
-        this._bobAddress = bobAddress;
-    }
-    get bobAddress() {
-        return this._bobAddress;
-    }
-}
-class ProSwapService extends BaseContractService {
-    constructor(_darkSwap) {
-        super(_darkSwap);
-    }
-    async prepare(address, orderNote, swapOutAmount, swapInAmount, bobAddress, bobSwapMessage, signature) {
-        const [pubKey, privKey] = await generateKeyPair(signature);
-        const changeNote = createNote(address, orderNote.asset, orderNote.amount - swapOutAmount, pubKey);
-        const swapInNote = createNote(address, bobSwapMessage.orderNote.asset, swapInAmount, pubKey);
-        const context = new ProSwapContext(signature);
-        context.orderNote = orderNote;
-        context.swapInNote = swapInNote;
-        context.changeNote = changeNote;
-        context.address = address;
-        context.bobAddress = bobAddress;
-        context.bobSwapMessage = bobSwapMessage;
-        return { context, swapInNote, changeNote };
-    }
-    async generateProof(context) {
-        if (!context
-            || !context.orderNote
-            || !context.swapInNote
-            || !context.changeNote
-            || !context.address
-            || !context.signature
-            || !context.bobSwapMessage
-            || !context.bobAddress) {
-            throw new DarkSwapError('Invalid context');
-        }
-        const merklePathes = await multiGetMerklePathAndRoot([context.orderNote.note, context.bobSwapMessage.orderNote.note], this._darkSwap);
-        const orderNotePath = merklePathes[0];
-        const bobSwapMessagePath = merklePathes[1];
-        const proof = await generateProSwapProof({
-            merkleRoot: orderNotePath.root,
-            aliceAddress: context.address,
-            aliceMerkleIndex: orderNotePath.index,
-            aliceMerklePath: orderNotePath.path,
-            aliceOrderNote: context.orderNote,
-            aliceChangeNote: context.changeNote,
-            aliceInNote: context.swapInNote,
-            aliceSignedMessage: context.signature,
-            bobAddress: context.bobAddress,
-            bobMerkleIndex: bobSwapMessagePath.index,
-            bobMerklePath: bobSwapMessagePath.path,
-            bobMessage: context.bobSwapMessage,
-        });
-        context.merkleRoot = orderNotePath.root;
-        context.proof = proof;
+	"__gt",
+	"directive_invert",
+	"directive_to_radix",
+	"directive_integer_quotient"
+];
+var swapCircuit = {
+	noir_version: noir_version$2,
+	hash: hash$2,
+	abi: abi$2,
+	bytecode: bytecode$2,
+	debug_symbols: debug_symbols$2,
+	file_map: file_map$2,
+	names: names$2,
+	brillig_names: brillig_names$2
+};
+
+async function generateProSwapProof(param) {
+    if (param.aliceOrderNote.feeRatio < 0n
+        || param.bobMessage.orderNote.feeRatio < 0n) {
+        throw new DarkSwapProofError("Invalid fee ratio");
     }
-    async execute(context) {
-        await this.generateProof(context);
-        if (!context
-            || !context.orderNote
-            || !context.swapInNote
-            || !context.changeNote
-            || !context.proof
-            || !context.bobSwapMessage
-            || !context.bobAddress) {
-            throw new DarkSwapError('Invalid context');
-        }
-        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
-        const tx = await contract.proSwap(context.proof.aliceOutNullifier, context.proof.aliceChangeNoteFooter, context.proof.aliceInNoteFooter, context.proof.bobOutNullifier, context.proof.bobInNoteFooter, context.proof.proof);
-        return tx.hash;
+    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 = {
+        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,
+    };
 }
 
 var noir_version$1 = "1.0.0-beta.6+e796dfd67726cbc28eb9991782533b211025928d";
@@ -6265,21 +6127,23 @@ var retailCreateOrderCircuit = {
 	brillig_names: brillig_names$1
 };
 
-async function generateRetailSwapMessage(address, orderNote, swapInNote, pubKey, privKey) {
+async function generateRetailSwapMessage(address, orderNote, swapInNote, feeAmount, pubKey, privKey) {
     const addressMod = encodeAddress(address);
-    const orderNoteNullifier = hexlify32(calcNullifier(orderNote.rho, pubKey));
+    const orderNoteNullifier = calcNullifier(orderNote.rho, pubKey);
     const message = bn_to_hex(mimc_bn254([
         BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
         addressMod,
-        orderNote.note,
+        orderNoteNullifier,
         orderNote.feeRatio,
         swapInNote.note,
     ]));
     const signature = await signMessage(message, privKey);
     return {
+        address: address,
         orderNote: orderNote,
-        orderNullifier: orderNoteNullifier,
+        orderNullifier: bn_to_0xhex(orderNoteNullifier),
         inNote: swapInNote,
+        feeAmount: feeAmount,
         publicKey: pubKey,
         signature: signatureToHexString(signature),
     };
@@ -6332,9 +6196,183 @@ async function generateRetailCreateOrderProof(param) {
     };
 }
 
-async function generateProSwapMessage(address, orderNote, swapInNote, signature) {
-    const [pubKey, privKey] = await generateKeyPair(signature);
-    return await generateRetailSwapMessage(address, orderNote, swapInNote, pubKey, privKey);
+class ProSwapContext extends BaseContext {
+    constructor(signature) {
+        super(signature);
+        Object.defineProperty(this, "_orderNote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_changeNote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_swapInNote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_proof", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_bobAddress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_bobSwapMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_aliceFeeAmount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    set orderNote(orderNote) {
+        this._orderNote = orderNote;
+    }
+    get orderNote() {
+        return this._orderNote;
+    }
+    set changeNote(changeNote) {
+        this._changeNote = changeNote;
+    }
+    get changeNote() {
+        return this._changeNote;
+    }
+    set swapInNote(swapInNote) {
+        this._swapInNote = swapInNote;
+    }
+    get swapInNote() {
+        return this._swapInNote;
+    }
+    set aliceFeeAmount(aliceFeeAmount) {
+        this._aliceFeeAmount = aliceFeeAmount;
+    }
+    get aliceFeeAmount() {
+        return this._aliceFeeAmount;
+    }
+    set proof(proof) {
+        this._proof = proof;
+    }
+    get proof() {
+        return this._proof;
+    }
+    set bobSwapMessage(bobSwapMessage) {
+        this._bobSwapMessage = bobSwapMessage;
+    }
+    get bobSwapMessage() {
+        return this._bobSwapMessage;
+    }
+    set bobAddress(bobAddress) {
+        this._bobAddress = bobAddress;
+    }
+    get bobAddress() {
+        return this._bobAddress;
+    }
+}
+class ProSwapService extends BaseContractService {
+    constructor(_darkSwap) {
+        super(_darkSwap);
+    }
+    static async prepareProSwapMessageForBob(address, orderNote, swapInAmount, swapInAsset, signature) {
+        const [pubKey, privKey] = await generateKeyPair(signature);
+        const feeAmount = swapInAmount * orderNote.feeRatio / FEE_RATIO_PRECISION;
+        const swapInNote = createNote(address, swapInAsset, swapInAmount - feeAmount, pubKey);
+        const darkSwapMessage = await generateRetailSwapMessage(address, orderNote, swapInNote, feeAmount, pubKey, privKey);
+        return darkSwapMessage;
+    }
+    async prepare(address, orderNote, bobAddress, bobSwapMessage, signature) {
+        const [pubKey] = await generateKeyPair(signature);
+        const swapOutAmount = bobSwapMessage.feeAmount + bobSwapMessage.inNote.amount;
+        const swapInAmount = bobSwapMessage.orderNote.amount;
+        const aliceFeeAmount = swapInAmount * orderNote.feeRatio / FEE_RATIO_PRECISION;
+        const changeNote = createNote(address, orderNote.asset, orderNote.amount - swapOutAmount, pubKey);
+        const swapInNote = createNote(address, bobSwapMessage.orderNote.asset, swapInAmount - aliceFeeAmount, pubKey);
+        const context = new ProSwapContext(signature);
+        context.orderNote = orderNote;
+        context.swapInNote = swapInNote;
+        context.changeNote = changeNote;
+        context.aliceFeeAmount = aliceFeeAmount;
+        context.address = address;
+        context.bobAddress = bobAddress;
+        context.bobSwapMessage = bobSwapMessage;
+        return { context, swapInNote, changeNote, feeAmount: aliceFeeAmount };
+    }
+    async generateProof(context) {
+        if (!context
+            || !context.orderNote
+            || !context.swapInNote
+            || !context.changeNote
+            || !context.address
+            || !context.signature
+            || !context.bobSwapMessage
+            || !context.bobAddress) {
+            throw new DarkSwapError('Invalid context');
+        }
+        const merklePathes = await multiGetMerklePathAndRoot([context.orderNote.note, context.bobSwapMessage.orderNote.note], this._darkSwap);
+        const orderNotePath = merklePathes[0];
+        const bobOrderNotePath = merklePathes[1];
+        const proof = await generateProSwapProof({
+            merkleRoot: orderNotePath.root,
+            aliceAddress: context.address,
+            aliceMerkleIndex: orderNotePath.index,
+            aliceMerklePath: orderNotePath.path,
+            aliceOrderNote: context.orderNote,
+            aliceChangeNote: context.changeNote,
+            aliceInNote: context.swapInNote,
+            aliceFeeAmount: context.aliceFeeAmount,
+            aliceSignedMessage: context.signature,
+            bobAddress: context.bobAddress,
+            bobMerkleIndex: bobOrderNotePath.index,
+            bobMerklePath: bobOrderNotePath.path,
+            bobMessage: context.bobSwapMessage,
+        });
+        context.merkleRoot = orderNotePath.root;
+        context.proof = proof;
+    }
+    async execute(context) {
+        await this.generateProof(context);
+        if (!context
+            || !context.orderNote
+            || !context.swapInNote
+            || !context.changeNote
+            || !context.proof
+            || !context.bobSwapMessage
+            || !context.bobAddress) {
+            throw new DarkSwapError('Invalid context');
+        }
+        const contract = new ethers.Contract(this._darkSwap.contracts.darkSwapAssetManager, DarkSwapAssetManagerAbi.abi, this._darkSwap.signer);
+        const tx = await contract.proSwap([
+            context.merkleRoot,
+            context.proof.aliceOutNullifier,
+            hexlify32(context.orderNote.feeRatio),
+            hexlify32(context.swapInNote.note),
+            context.proof.aliceInNoteFooter,
+            hexlify32(context.changeNote.note),
+            context.proof.aliceChangeNoteFooter,
+            context.proof.bobOutNullifier,
+            hexlify32(context.bobSwapMessage.orderNote.feeRatio),
+            hexlify32(context.bobSwapMessage.inNote.note),
+            context.proof.bobInNoteFooter
+        ], context.proof.proof);
+        await tx.wait();
+        return tx.hash;
+    }
 }
 
 var noir_version = "1.0.0-beta.6+e796dfd67726cbc28eb9991782533b211025928d";
@@ -6709,7 +6747,7 @@ class RetailCreateOrderService extends BaseContractService {
         context.swapInNote = swapInNote;
         context.feeAmount = feeAmount;
         context.address = address;
-        const swapMessage = await generateRetailSwapMessage(address, orderNote, swapInNote, pubKey, privKey);
+        const swapMessage = await generateRetailSwapMessage(address, orderNote, swapInNote, feeAmount, pubKey, privKey);
         context.swapMessage = swapMessage;
         return { context, swapMessage };
     }
@@ -6851,19 +6889,33 @@ class DarkSwap {
 
 function serializeDarkSwapMessage(swapMessage) {
     return JSON.stringify({
-        orderNote: swapMessage.orderNote,
-        inNote: swapMessage.inNote,
-        signature: swapMessage.signature,
-        pubKey: [swapMessage.publicKey[0].toString(), swapMessage.publicKey[1].toString()],
+        address: swapMessage.address,
+        orderNote: {
+            rho: swapMessage.orderNote.rho.toString(),
+            amount: swapMessage.orderNote.amount.toString(),
+            asset: swapMessage.orderNote.asset,
+            note: swapMessage.orderNote.note.toString(),
+            feeRatio: swapMessage.orderNote.feeRatio.toString(),
+        },
         orderNullifier: swapMessage.orderNullifier,
+        inNote: {
+            rho: swapMessage.inNote.rho.toString(),
+            amount: swapMessage.inNote.amount.toString(),
+            asset: swapMessage.inNote.asset,
+            note: swapMessage.inNote.note.toString(),
+        },
+        feeAmount: swapMessage.feeAmount.toString(),
+        pubKey: [swapMessage.publicKey[0].toString(), swapMessage.publicKey[1].toString()],
+        signature: swapMessage.signature,
     });
 }
 function deserializePublicKey(publicKeyString) {
-    return [Fr.fromBuffer(Buffer.from(publicKeyString[0], 'hex')), Fr.fromBuffer(Buffer.from(publicKeyString[1], 'hex'))];
+    return [Fr.fromHexString(publicKeyString[0]), Fr.fromHexString(publicKeyString[1])];
 }
 function deserializeDarkSwapMessage(serializedMessage) {
     const message = JSON.parse(serializedMessage);
     return {
+        address: message.address,
         orderNote: {
             rho: BigInt(message.orderNote.rho),
             amount: BigInt(message.orderNote.amount),
@@ -6871,6 +6923,7 @@ function deserializeDarkSwapMessage(serializedMessage) {
             note: BigInt(message.orderNote.note),
             feeRatio: BigInt(message.orderNote.feeRatio),
         },
+        feeAmount: BigInt(message.feeAmount),
         inNote: {
             rho: BigInt(message.inNote.rho),
             amount: BigInt(message.inNote.amount),
@@ -6883,5 +6936,5 @@ function deserializeDarkSwapMessage(serializedMessage) {
     };
 }
 
-export { ChainId, DEFAULT_FEE_RATIO, DarkSwap, DarkSwapError, DarkSwapProofError, DepositContext, DepositService, EMPTY_FOOTER, EMPTY_NULLIFIER, EMPTY_PATH, FEE_RATIO_PRECISION, JoinService, NoteOnChainStatus, PROOF_DOMAIN, ProCancelOrderService, ProCreateOrderService, ProSwapService, RetailCancelOrderService, RetailCreateOrderService, TripleJoinService, WithdrawService, contractConfig, deserializeDarkSwapMessage, generateKeyPair, generateProSwapMessage, getFeeRatio, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, getNoteOnChainStatusBySignature, getNullifierBySignature, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, legacyTokenConfig, multiGetMerklePathAndRoot, serializeDarkSwapMessage };
+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, TripleJoinService, WithdrawService, calcNullifier, contractConfig, createNote, createOrderNoteExt, deserializeDarkSwapMessage, generateKeyPair, getFeeRatio, getMerklePathAndRoot, getNoteFooter, getNoteOnChainStatusByPublicKey, getNoteOnChainStatusBySignature, getNullifierBySignature, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, legacyTokenConfig, multiGetMerklePathAndRoot, serializeDarkSwapMessage };
 //# sourceMappingURL=index.esm.js.map