@thesingularitynetwork/darkswap-sdk 0.1.11 → 0.1.13

package/dist/index.umd.js.map

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

package/dist/types/src/index.d.ts

@@ -3,6 +3,7 @@ export * from './entities';
 export * from './darkSwap';
 export * from './utils/util';
 export * from './proof/keyService';
+export * from './proof/noteService';
 export * from './config';
 export * from './types';
 export * from './utils/swapUtils';

package/dist/types/src/proof/pro/orders/swapProof.d.ts

@@ -5,6 +5,7 @@ export type ProSwapProofParam = {
     aliceMerklePath: string[];
     aliceAddress: string;
     aliceOrderNote: DarkSwapOrderNote;
+    aliceFeeAmount: bigint;
     aliceInNote: DarkSwapNote;
     aliceChangeNote: DarkSwapNote;
     aliceSignedMessage: string;

package/dist/types/src/proof/retail/depositOrderProof.d.ts

@@ -10,5 +10,5 @@ export type RetailCreateOrderProofResult = BaseProofResult & {
     depositFooter: string;
     swapInNoteFooter: string;
 };
-export declare function generateRetailSwapMessage(address: string, orderNote: DarkSwapOrderNote, swapInNote: DarkSwapNote, pubKey: [Fr, Fr], privKey: Fr): Promise<DarkSwapMessage>;
+export declare function generateRetailSwapMessage(address: string, orderNote: DarkSwapOrderNote, swapInNote: DarkSwapNote, feeAmount: bigint, pubKey: [Fr, Fr], privKey: Fr): Promise<DarkSwapMessage>;
 export declare function generateRetailCreateOrderProof(param: RetailCreateOrderProofParam): Promise<RetailCreateOrderProofResult>;

package/dist/types/src/proof/retail/swapProof.d.ts

@@ -3,11 +3,9 @@ export type RetailSwapProofParam = {
     merkleRoot: string;
     aliceMerkleIndex: number[];
     aliceMerklePath: string[];
-    aliceAddress: string;
     aliceMessage: DarkSwapMessage;
     bobMerkleIndex: number[];
     bobMerklePath: string[];
-    bobAddress: string;
     bobMessage: DarkSwapMessage;
 };
 export type RetailSwapProofResult = BaseProofResult & {

package/dist/types/src/services/agent/index.d.ts

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

package/dist/types/src/services/agent/retailSwap.d.ts

@@ -0,0 +1,25 @@
+import { DarkSwap } from '../../darkSwap';
+import { RetailSwapProofResult } from '../../proof/retail/swapProof';
+import { DarkSwapMessage } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class RetailSwapContext extends BaseContext {
+    private _aliceSwapMessage?;
+    private _bobSwapMessage?;
+    private _proof?;
+    constructor(signature: string);
+    set aliceSwapMessage(aliceSwapMessage: DarkSwapMessage | undefined);
+    get aliceSwapMessage(): DarkSwapMessage | undefined;
+    set bobSwapMessage(bobSwapMessage: DarkSwapMessage | undefined);
+    get bobSwapMessage(): DarkSwapMessage | undefined;
+    set proof(proof: RetailSwapProofResult | undefined);
+    get proof(): RetailSwapProofResult | undefined;
+}
+export declare class RetailSwapService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(aliceSwapMessage: DarkSwapMessage, bobSwapMessage: DarkSwapMessage): Promise<{
+        context: RetailSwapContext;
+    }>;
+    private generateProof;
+    execute(context: RetailSwapContext): Promise<string>;
+}
+export {};

package/dist/types/src/services/pro/index.d.ts

@@ -1,4 +1,3 @@
 export * from './createOrder';
 export * from './cancelOrder';
 export * from './proSwap';
-export * from './swapMessage';

package/dist/types/src/services/pro/proSwap.d.ts

@@ -9,6 +9,7 @@ declare class ProSwapContext extends BaseContext {
     private _proof?;
     private _bobAddress?;
     private _bobSwapMessage?;
+    private _aliceFeeAmount?;
     constructor(signature: string);
     set orderNote(orderNote: DarkSwapOrderNote | undefined);
     get orderNote(): DarkSwapOrderNote | undefined;
@@ -16,6 +17,8 @@ declare class ProSwapContext extends BaseContext {
     get changeNote(): DarkSwapNote | undefined;
     set swapInNote(swapInNote: DarkSwapNote | undefined);
     get swapInNote(): DarkSwapNote | undefined;
+    set aliceFeeAmount(aliceFeeAmount: bigint | undefined);
+    get aliceFeeAmount(): bigint | undefined;
     set proof(proof: ProSwapProofResult | undefined);
     get proof(): ProSwapProofResult | undefined;
     set bobSwapMessage(bobSwapMessage: DarkSwapMessage | undefined);
@@ -25,10 +28,12 @@ declare class ProSwapContext extends BaseContext {
 }
 export declare class ProSwapService extends BaseContractService {
     constructor(_darkSwap: DarkSwap);
-    prepare(address: string, orderNote: DarkSwapOrderNote, swapOutAmount: bigint, swapInAmount: bigint, bobAddress: string, bobSwapMessage: DarkSwapMessage, signature: string): Promise<{
+    static prepareProSwapMessageForBob(address: string, orderNote: DarkSwapOrderNote, swapInAmount: bigint, swapInAsset: string, signature: string): Promise<DarkSwapMessage>;
+    prepare(address: string, orderNote: DarkSwapOrderNote, bobAddress: string, bobSwapMessage: DarkSwapMessage, signature: string): Promise<{
         context: ProSwapContext;
         swapInNote: DarkSwapNote;
         changeNote: DarkSwapNote;
+        feeAmount: bigint;
     }>;
     private generateProof;
     execute(context: ProSwapContext): Promise<string>;

package/dist/types/src/services/pro/swapMessage.d.ts

@@ -1,2 +1,2 @@
-import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from "../..";
-export declare function generateProSwapMessage(address: string, orderNote: DarkSwapOrderNote, swapInNote: DarkSwapNote, signature: string): Promise<DarkSwapMessage>;
+import { DarkSwapMessage, DarkSwapOrderNote } from "../..";
+export declare function prepareProSwapMessageForBob(address: string, orderNote: DarkSwapOrderNote, swapInAmount: bigint, swapInAsset: string, signature: string): Promise<DarkSwapMessage>;

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

@@ -49,9 +49,11 @@ export type BaseProofInput = {
     signature: any;
 };
 export type DarkSwapMessage = {
+    address: string;
     orderNote: DarkSwapOrderNote;
     orderNullifier: string;
     inNote: DarkSwapNote;
+    feeAmount: bigint;
     publicKey: [Fr, Fr];
     signature: string;
 };

package/dist/types/test/services/pro/proSwap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/utils/helpers.d.ts

@@ -1,6 +1,9 @@
 import { ethers } from "ethers";
 import { DarkSwap } from "../../src";
 export declare function getAliceWallet(): ethers.Wallet;
+export declare function getBobWallet(): ethers.Wallet;
 export declare function getAliceSignature(): Promise<string>;
+export declare function getBobSignature(): Promise<string>;
 export declare function getAliceWalletBalance(asset: string): Promise<any>;
 export declare function getDarkSwapForAlice(): DarkSwap;
+export declare function getDarkSwapForBob(): DarkSwap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thesingularitynetwork/darkswap-sdk",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "DarkSwap SDK for browser and Node.js",
   "type": "module",
   "types": "dist/types/src/index.d.ts",

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './entities';
 export * from './darkSwap';
 export * from './utils/util';
 export * from './proof/keyService';
+export * from './proof/noteService';
 export * from './config';
 export * from './types';
 export * from './utils/swapUtils';

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

@@ -1,5 +1,5 @@
 import swapCircuit from "../../../circuits/pro/dark_swap_pro_swap_compiled_circuit.json";
-import { BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, FEE_RATIO_PRECISION, PROOF_DOMAIN } from "../../../types";
+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";
@@ -72,6 +72,7 @@ export type ProSwapProofParam = {
     aliceMerklePath: string[],
     aliceAddress: string,
     aliceOrderNote: DarkSwapOrderNote,
+    aliceFeeAmount: bigint,
     aliceInNote: DarkSwapNote,
     aliceChangeNote: DarkSwapNote,
     aliceSignedMessage: string,
@@ -104,19 +105,16 @@ export async function generateProSwapProof(param: ProSwapProofParam): Promise<Pr
         throw new DarkSwapProofError("Invalid note amount");
     }
 
-    if (param.aliceOrderNote.amount != param.aliceChangeNote.amount - param.bobMessage.inNote.amount
-        || param.bobMessage.orderNote.amount != param.aliceInNote.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 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 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);
 
@@ -136,7 +134,6 @@ export async function generateProSwapProof(param: ProSwapProofParam): Promise<Pr
 
     const inputs: ProSwapProofInput = {
         merkle_root: param.merkleRoot,
-
         alice_merkle_index: param.aliceMerkleIndex,
         alice_merkle_path: param.aliceMerklePath,
         alice_address: bn_to_0xhex(aliceAddressMod),
@@ -145,7 +142,7 @@ export async function generateProSwapProof(param: ProSwapProofParam): Promise<Pr
         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_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),
@@ -161,7 +158,7 @@ export async function generateProSwapProof(param: ProSwapProofParam): Promise<Pr
         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_in_amount: bn_to_0xhex(param.bobMessage.inNote.amount + param.bobMessage.feeAmount),
 
         bob_merkle_index: param.bobMerkleIndex,
         bob_merkle_path: param.bobMerklePath,
@@ -171,7 +168,7 @@ export async function generateProSwapProof(param: ProSwapProofParam): Promise<Pr
         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_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),

package/src/proof/retail/depositOrderProof.ts

@@ -49,25 +49,28 @@ export async function generateRetailSwapMessage(
     address: string,
     orderNote: DarkSwapOrderNote,
     swapInNote: DarkSwapNote,
+    feeAmount: bigint,
     pubKey: [Fr, Fr],
     privKey: Fr
 ): Promise<DarkSwapMessage> {
 
     const addressMod = encodeAddress(address);
-    const orderNoteNullifier = 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),
     }

package/src/proof/retail/swapProof.ts

@@ -1,12 +1,9 @@
-import { Field } from "@noir-lang/types";
 import retailSwapCircuit from "../../circuits/retail/dark_swap_retail_swap_compiled_circuit.json";
-import { BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, DarkSwapProofError, FEE_RATIO_PRECISION, PROOF_DOMAIN } from "../../types";
+import { BaseProofResult, DarkSwapMessage, DarkSwapProofError, FEE_RATIO_PRECISION } from "../../types";
 import { encodeAddress } from "../../utils/encoders";
-import { bn_to_0xhex, bn_to_hex } from "../../utils/formatters";
-import { mimc_bn254 } from "../../utils/mimc";
+import { bn_to_0xhex } from "../../utils/formatters";
 import { hexStringToSignature, uint8ArrayToNumberArray } from "../../utils/proofUtils";
-import { generateProof, signMessage } from "../baseProofService";
-import { generateKeyPair } from "../keyService";
+import { generateProof } from "../baseProofService";
 import { calcNullifier, getNoteFooter } from "../noteService";
 
 type RetailSwapProofInput = {
@@ -65,12 +62,10 @@ export type RetailSwapProofParam = {
     merkleRoot: string,
     aliceMerkleIndex: number[],
     aliceMerklePath: string[],
-    aliceAddress: string,
     aliceMessage: DarkSwapMessage,
 
     bobMerkleIndex: number[],
     bobMerklePath: string[],
-    bobAddress: string,
     bobMessage: DarkSwapMessage,
 }
 
@@ -108,8 +103,8 @@ export async function generateRetailSwapProof(param: RetailSwapProofParam): Prom
     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 aliceAddressMod = encodeAddress(param.aliceMessage.address);
+    const bobAddressMod = encodeAddress(param.bobMessage.address);
 
     const inputs: RetailSwapProofInput = {
         merkle_root: param.merkleRoot,

package/src/services/agent/index.ts

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

package/src/services/agent/retailSwap.ts

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

package/src/services/pro/cancelOrder.ts

@@ -128,7 +128,7 @@ export class ProCancelOrderService extends BaseContractService {
       DarkSwapAssetManagerAbi.abi,
       this._darkSwap.signer
     );
-    const tx = await contract.proCancelOrder(
+    const tx = await contract.cancelOrder(
       context.merkleRoot,
       context.proof.orderNullifier,
       context.proof.oldBalanceNullifier,

package/src/services/pro/createOrder.ts

@@ -1,15 +1,15 @@
 import { ethers } from 'ethers';
 import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-import { getFeeRatio } from '../feeRatioService';
 import { DarkSwap } from '../../darkSwap';
 import { DarkSwapError } from '../../entities';
 import { generateKeyPair } from '../../proof/keyService';
 import { calcNullifier, createNote, createOrderNoteExt } from '../../proof/noteService';
 import { generateProCreateOrderProof, ProCreateOrderProofResult } from '../../proof/pro/orders/createOrderProof';
 import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, DarkSwapOrderNoteExt } from '../../types';
+import { hexlify32 } from '../../utils/util';
 import { BaseContext, BaseContractService } from '../BaseService';
+import { getFeeRatio } from '../feeRatioService';
 import { getMerklePathAndRoot } from '../merkletree';
-import { hexlify32 } from '../../utils/util';
 
 class ProCreateOrderContext extends BaseContext {
   private _orderNote?: DarkSwapOrderNote;

package/src/services/pro/index.ts

@@ -1,4 +1,3 @@
 export * from './createOrder';
 export * from './cancelOrder';
-export * from './proSwap';
-export * from './swapMessage';
+export * from './proSwap';

package/src/services/pro/proSwap.ts

@@ -5,9 +5,11 @@ import { DarkSwapError } from '../../entities';
 import { generateKeyPair } from '../../proof/keyService';
 import { createNote } from '../../proof/noteService';
 import { generateProSwapProof, ProSwapProofResult } from '../../proof/pro/orders/swapProof';
-import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from '../../types';
+import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote, FEE_RATIO_PRECISION } from '../../types';
 import { BaseContext, BaseContractService } from '../BaseService';
 import { multiGetMerklePathAndRoot } from '../merkletree';
+import { hexlify32 } from '../../utils/util';
+import { generateRetailSwapMessage } from '../../proof/retail/depositOrderProof';
 
 class ProSwapContext extends BaseContext {
     private _orderNote?: DarkSwapOrderNote;
@@ -16,6 +18,7 @@ class ProSwapContext extends BaseContext {
     private _proof?: ProSwapProofResult;
     private _bobAddress?: string;
     private _bobSwapMessage?: DarkSwapMessage;
+    private _aliceFeeAmount?: bigint;
 
     constructor(signature: string) {
         super(signature);
@@ -45,6 +48,14 @@ class ProSwapContext extends BaseContext {
         return this._swapInNote;
     }
 
+    set aliceFeeAmount(aliceFeeAmount: bigint | undefined) {
+        this._aliceFeeAmount = aliceFeeAmount;
+    }
+
+    get aliceFeeAmount(): bigint | undefined {
+        return this._aliceFeeAmount;
+    }
+
     set proof(proof: ProSwapProofResult | undefined) {
         this._proof = proof;
     }
@@ -75,27 +86,43 @@ export class ProSwapService extends BaseContractService {
         super(_darkSwap);
     }
 
-    public async prepare(
+    public static async prepareProSwapMessageForBob(
         address: string,
         orderNote: DarkSwapOrderNote,
-        swapOutAmount: bigint,
         swapInAmount: bigint,
+        swapInAsset: string,
+        signature: string
+    ): Promise<DarkSwapMessage> {
+        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;
+    }
+
+    public async prepare(
+        address: string,
+        orderNote: DarkSwapOrderNote,
         bobAddress: string,
         bobSwapMessage: DarkSwapMessage,
         signature: string
-    ): Promise<{ context: ProSwapContext; swapInNote: DarkSwapNote, changeNote: DarkSwapNote }> {
-        const [pubKey, privKey] = await generateKeyPair(signature);
+    ): Promise<{ context: ProSwapContext; swapInNote: DarkSwapNote, changeNote: DarkSwapNote, feeAmount: bigint }> {
+        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, 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 };
+        return { context, swapInNote, changeNote, feeAmount: aliceFeeAmount };
     }
 
     private async generateProof(context: ProSwapContext): Promise<void> {
@@ -112,7 +139,7 @@ export class ProSwapService extends BaseContractService {
 
         const merklePathes = await multiGetMerklePathAndRoot([context.orderNote.note, context.bobSwapMessage.orderNote.note], this._darkSwap);
         const orderNotePath = merklePathes[0];
-        const bobSwapMessagePath = merklePathes[1];
+        const bobOrderNotePath = merklePathes[1];
 
         const proof = await generateProSwapProof({
             merkleRoot: orderNotePath.root,
@@ -122,10 +149,11 @@ export class ProSwapService extends BaseContractService {
             aliceOrderNote: context.orderNote,
             aliceChangeNote: context.changeNote,
             aliceInNote: context.swapInNote,
+            aliceFeeAmount: context.aliceFeeAmount!,
             aliceSignedMessage: context.signature,
             bobAddress: context.bobAddress,
-            bobMerkleIndex: bobSwapMessagePath.index,
-            bobMerklePath: bobSwapMessagePath.path,
+            bobMerkleIndex: bobOrderNotePath.index,
+            bobMerklePath: bobOrderNotePath.path,
             bobMessage: context.bobSwapMessage,
         });
         context.merkleRoot = orderNotePath.root;
@@ -134,7 +162,7 @@ export class ProSwapService extends BaseContractService {
 
     public async execute(context: ProSwapContext): Promise<string> {
         await this.generateProof(context);
-        if (!context 
+        if (!context
             || !context.orderNote
             || !context.swapInNote
             || !context.changeNote
@@ -150,13 +178,22 @@ export class ProSwapService extends BaseContractService {
             this._darkSwap.signer
         );
         const tx = await contract.proSwap(
-            context.proof.aliceOutNullifier,
-            context.proof.aliceChangeNoteFooter,
-            context.proof.aliceInNoteFooter,
-            context.proof.bobOutNullifier,
-            context.proof.bobInNoteFooter,
+            [
+                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;
     }
 }

package/src/services/retail/depositAndCreateOrder.ts

@@ -90,7 +90,7 @@ export class RetailCreateOrderService extends BaseContractService {
     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 };
   }