npm - @thesingularitynetwork/darkswap-sdk - Versions diffs - 0.2.2 → 0.2.4 - Mend

@thesingularitynetwork/darkswap-sdk 0.2.2 → 0.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/darkswap-sdk.cjs.development.js +1623 -424
package/dist/darkswap-sdk.cjs.development.js.map +1 -1
package/dist/darkswap-sdk.cjs.production.min.js +1 -1
package/dist/darkswap-sdk.cjs.production.min.js.map +1 -1
package/dist/darkswap-sdk.esm.js +1384 -187
package/dist/darkswap-sdk.esm.js.map +1 -1
package/dist/proof/synara/bridgeOrderProof.d.ts +0 -1
package/dist/services/synara/bridgeAndCreateOrder.d.ts +14 -4
package/package.json +1 -1

package/dist/darkswap-sdk.cjs.development.js CHANGED Viewed

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 var ethers = require('ethers');
 var bb_js = require('@aztec/bb.js');
 require('buffer');
 var noir_js = require('@noir-lang/noir_js');
+var axios = _interopDefault(require('axios'));
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -10085,445 +10088,1641 @@ var RetailSwapService = /*#__PURE__*/function (_BaseContractService) {
   return RetailSwapService;
 }(BaseContractService);
-var _DOMAIN_PREFIX = "0x191253796e6172614272696467654465706f7369740a";
-var BridgeCreateOrderContext = /*#__PURE__*/function (_BaseContext) {
-  function BridgeCreateOrderContext(signature) {
-    return _BaseContext.call(this, signature) || this;
-  }
-  _inheritsLoose(BridgeCreateOrderContext, _BaseContext);
-  return _createClass(BridgeCreateOrderContext, [{
-    key: "orderNote",
-    get: function get() {
-      return this._orderNote;
-    },
-    set: function set(orderNote) {
-      this._orderNote = orderNote;
-    }
-  }, {
-    key: "swapInNote",
-    get: function get() {
-      return this._swapInNote;
-    },
-    set: function set(swapInNote) {
-      this._swapInNote = swapInNote;
-    }
-  }, {
-    key: "feeAmount",
-    get: function get() {
-      return this._feeAmount;
-    },
-    set: function set(feeAmount) {
-      this._feeAmount = feeAmount;
-    }
-  }, {
-    key: "proof",
-    get: function get() {
-      return this._proof;
-    },
-    set: function set(proof) {
-      this._proof = proof;
-    }
-  }, {
-    key: "swapMessage",
-    get: function get() {
-      return this._swapMessage;
-    },
-    set: function set(swapMessage) {
-      this._swapMessage = swapMessage;
-    }
-  }, {
-    key: "sourceChainId",
-    get: function get() {
-      return this._sourceChainId;
-    },
-    set: function set(sourceChainId) {
-      this._sourceChainId = sourceChainId;
-    }
-  }, {
-    key: "destChainId",
-    get: function get() {
-      return this._destChainId;
-    },
-    set: function set(destChainId) {
-      this._destChainId = destChainId;
-    }
-  }, {
-    key: "sourceAsset",
-    get: function get() {
-      return this._sourceAsset;
-    },
-    set: function set(sourceAsset) {
-      this._sourceAsset = sourceAsset;
-    }
-  }, {
-    key: "sourceAmount",
-    get: function get() {
-      return this._sourceAmount;
-    },
-    set: function set(sourceAmount) {
-      this._sourceAmount = sourceAmount;
-    }
-  }, {
-    key: "bridgeFeeAmount",
-    get: function get() {
-      return this._bridgeFeeAmount;
-    },
-    set: function set(bridgeFeeAmount) {
-      this._bridgeFeeAmount = bridgeFeeAmount;
-    }
-  }, {
-    key: "depositId",
-    get: function get() {
-      return this._depositId;
-    },
-    set: function set(depositId) {
-      this._depositId = depositId;
-    }
-  }, {
-    key: "attestationDetails",
-    get: function get() {
-      return this._attestationDetails;
-    },
-    set: function set(attestationDetails) {
-      this._attestationDetails = attestationDetails;
-    }
-  }, {
-    key: "relayer",
-    get: function get() {
-      return this._relayer;
-    },
-    set: function set(relayer) {
-      this._relayer = relayer;
-    }
-  }, {
-    key: "jobId",
-    get: function get() {
-      return this._jobId;
-    },
-    set: function set(jobId) {
-      this._jobId = jobId;
-    }
-  }, {
-    key: "canonicalId",
-    get: function get() {
-      return this._canonicalId;
-    },
-    set: function set(canonicalId) {
-      this._canonicalId = canonicalId;
-    }
-  }, {
-    key: "callDataHash",
-    get: function get() {
-      return this._callDataHash;
-    },
-    set: function set(callDataHash) {
-      this._callDataHash = callDataHash;
-    }
-  }, {
-    key: "nonce",
-    get: function get() {
-      return this._nonce;
-    },
-    set: function set(nonce) {
-      this._nonce = nonce;
-    }
-  }]);
-}(BaseContext);
-var BridgeCreateOrderService = /*#__PURE__*/function () {
-  function BridgeCreateOrderService(_darkSwapOfSourceChain, _darkSwapOfDestChain) {
-    this._darkSwapOfSourceChain = _darkSwapOfSourceChain;
-    this._darkSwapOfDestChain = _darkSwapOfDestChain;
-  }
-  var _proto = BridgeCreateOrderService.prototype;
-  _proto.prepare = /*#__PURE__*/function () {
-    var _prepare = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(address, sourceChainId, sourceAsset, sourceAmount, canonicalId, bridgeFee, destChainId, depositAsset, depositAmount, swapInAsset, swapInAmount, signature) {
-      var _yield$generateKeyPai, pubKey, privKey, feeRatio, orderNote, feeAmount, realSwapInAmount, swapInNote, context, swapMessage, _t, _t2;
-      return _regenerator().w(function (_context) {
-        while (1) switch (_context.n) {
-          case 0:
-            _context.n = 1;
-            return generateKeyPair(signature);
-          case 1:
-            _yield$generateKeyPai = _context.v;
-            pubKey = _yield$generateKeyPai[0];
-            privKey = _yield$generateKeyPai[1];
-            _t = BigInt;
-            _context.n = 2;
-            return getFeeRatio(address, this._darkSwapOfDestChain);
-          case 2:
-            _t2 = _context.v;
-            feeRatio = _t(_t2);
-            orderNote = createOrderNoteExt(address, depositAsset, depositAmount, feeRatio, pubKey);
-            feeAmount = calcFeeAmount(swapInAmount, feeRatio);
-            realSwapInAmount = swapInAmount - feeAmount;
-            swapInNote = createNote(address, swapInAsset, realSwapInAmount, pubKey);
-            context = new BridgeCreateOrderContext(signature);
-            context.orderNote = orderNote;
-            context.swapInNote = swapInNote;
-            context.feeAmount = feeAmount;
-            context.address = address;
-            context.sourceChainId = sourceChainId;
-            context.destChainId = destChainId;
-            context.sourceAsset = sourceAsset;
-            context.sourceAmount = sourceAmount;
-            context.bridgeFeeAmount = bridgeFee;
-            context.canonicalId = canonicalId;
-            _context.n = 3;
-            return generateRetailSwapMessage(address, orderNote, swapInNote, feeAmount, pubKey, privKey);
-          case 3:
-            swapMessage = _context.v;
-            context.swapMessage = swapMessage;
-            return _context.a(2, {
-              context: context,
-              swapMessage: swapMessage
-            });
-        }
-      }, _callee, this);
-    }));
-    function prepare(_x, _x2, _x3, _x4, _x5, _x6, _x7, _x8, _x9, _x0, _x1, _x10) {
-      return _prepare.apply(this, arguments);
-    }
-    return prepare;
-  }() // private pickRelayer() {
-  //   return this._darkSwapOfSourceChain.contracts.zkverifyRelayerUrls[0];
-  // }
-  // private async submitProof(context: BridgeCreateOrderContext): Promise<string> {
-  //   if (!context
-  //     || !context.proof
-  //     || !context.orderNote
-  //     || !context.swapInNote
-  //     || !context.address
-  //     || !context.feeAmount
-  //     || !context.signature
-  //     || !context.sourceChainId
-  //     || !context.destChainId
-  //     || !context.sourceAsset
-  //     || !context.sourceAmount
-  //     || !context.bridgeFeeAmount
-  //     || !context.depositId) {
-  //     throw new DarkSwapError('Invalid context');
-  //   }
-  //   const relayerRequest: SubmitProofRelayerRequest = {
-  //     proof: context.proof.proof,
-  //     publicSignals: context.proof.verifyInputs,
-  //     vkHash: VK_HASH_CONFIG[PROOF_DOMAIN.RETAIL_BRIDGE_ORDER],
-  //   }
-  //   context.relayer = this.pickRelayer();
-  //   const response = await axios.post(context.relayer + '/v1/zkVerifySubmitProof', relayerRequest);
-  //   if (response.status == 200) {
-  //     context.jobId = response.data.id;
-  //     return response.data.id;
-  //   } else if (response.status == 400) {
-  //     throw new Error('Request error' + response.data.error);
-  //   } else {
-  //     throw new Error('Relayer not asscessable');
-  //   }
-  // }
-  // private async pollJobStatus(context: BridgeCreateOrderContext): Promise<{ error: string | undefined; txHash: string | undefined }> {
-  //   let tries = 1;
-  //   let txHash = undefined;
-  //   while (tries <= 100) {
-  //     if (tries >= 100) {
-  //       break;
-  //     }
-  //     try {
-  //       const response = await axios.get(`${context.relayer}/v1/jobs/${context.jobId}`);
-  //       if (response.status === 400) {
-  //         const { error } = response.data;
-  //         console.log(error);
-  //         return {
-  //           error: 'Failed to submit transaction to relayer:' + error,
-  //           txHash: undefined
-  //         };
-  //       }
-  //       if (response.status === 200) {
-  //         const { txHash, status, failedReason } = response.data;
-  //         context.tx = txHash;
-  //         if (status === 'FAILED') {
-  //           return {
-  //             error: failedReason ?? 'Transaction failed.',
-  //             txHash: txHash
-  //           };
-  //         }
-  //         if (status === 'CONFIRMED' || status === 'MINED') {
-  //           return {
-  //             error: undefined,
-  //             txHash: txHash
-  //           };
-  //         }
-  //       }
-  //       await new Promise(resolve => setTimeout(resolve, 5000));
-  //     } catch (error) {
-  //       console.log(error);
-  //     }
-  //     tries++;
-  //   }
-  //   return {
-  //     error: 'Waited too long for transaction to be mined.',
-  //     txHash
-  //   };
-  // }
-  // private async generateProof(context: BridgeCreateOrderContext): Promise<RetailBridgeOrderProofResult> {
-  //   if (!context
-  //     || !context.orderNote
-  //     || !context.swapInNote
-  //     || !context.address
-  //     || !context.feeAmount
-  //     || !context.signature
-  //     || !context.sourceChainId
-  //     || !context.destChainId
-  //     || !context.sourceAsset
-  //     || !context.sourceAmount
-  //     || !context.bridgeFeeAmount
-  //     || !context.depositId) {
-  //     throw new DarkSwapError('Invalid context');
-  //   }
-  //   const proof = await generateRetailBridgeOrderProof({
-  //     depositSourceAsset: context.sourceAsset,
-  //     depositNote: context.orderNote,
-  //     swapInNote: context.swapInNote,
-  //     feeRatio: context.orderNote.feeRatio,
-  //     feeAmount: context.feeAmount,
-  //     destChain: context.destChainId,
-  //     depositId: context.depositId,
-  //     bridgeFeeAmount: context.bridgeFeeAmount,
-  //     address: context.address,
-  //     signedMessage: context.signature,
-  //   });
-  //   return proof;
-  // }
-  ;
-  _proto.computeDepositId =
-  /*#__PURE__*/
-  function () {
-    var _computeDepositId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(context) {
-      var callDataHash, packedData, depositCommitment;
-      return _regenerator().w(function (_context2) {
-        while (1) switch (_context2.n) {
-          case 0:
-            if (!(!context || !context.orderNote || !context.swapInNote || !context.address || !context.feeAmount || !context.signature || !context.sourceChainId || !context.destChainId || !context.sourceAsset || !context.sourceAmount || !context.bridgeFeeAmount)) {
-              _context2.n = 1;
-              break;
-            }
-            throw new DarkSwapError('Invalid context');
-          case 1:
-            callDataHash = "0x0";
-            context.callDataHash = callDataHash;
-            context.nonce = 1n;
-            packedData = ethers.solidityPacked(["bytes", "address", "bytes32", "address", "address", "uint256", "uint256", "uint256", "uint256", "bytes32" // _computeCallDataHash(call)
-            ], [_DOMAIN_PREFIX, this._darkSwapOfSourceChain.contracts.synaraBridge, context.canonicalId, this._darkSwapOfSourceChain.contracts.synaraDarkSwapOnBridgeAssetManager, context.address, context.sourceAmount, hexlify32(context.destChainId), hexlify32(context.nonce), hexlify32(context.sourceChainId), context.callDataHash]);
-            depositCommitment = ethers.keccak256(packedData);
-            return _context2.a(2, depositCommitment);
-        }
-      }, _callee2, this);
-    }));
-    function computeDepositId(_x11) {
-      return _computeDepositId.apply(this, arguments);
-    }
-    return computeDepositId;
-  }() // public async composeCallData(context: BridgeCreateOrderContext, attestationDetails: AttestationDetails): Promise<string> {
-  //   if (!context
-  //     || !context.orderNote
-  //     || !context.swapInNote
-  //     || !context.address
-  //     || !context.feeAmount
-  //     || !context.signature
-  //     || !context.sourceChainId
-  //     || !context.destChainId
-  //     || !context.sourceAsset
-  //     || !context.sourceAmount
-  //     || !context.bridgeFeeAmount
-  //     || !context.depositId
-  //     || !context.proof) {
-  //     throw new DarkSwapError('Invalid context');
-  //   }
-  //   const args: RetailDepositBridgeCreateOrderArgs = {
-  //     destChain: BigInt(context.destChainId),
-  //     depositId: context.depositId,
-  //     bridgeFee: context.bridgeFeeAmount,
-  //     owner: context.address,
-  //     depositOutNote: hexlify32(context.orderNote.note),
-  //     depositOutNoteFooter: context.proof.depositFooter,
-  //     outAssetSource: context.sourceAsset,
-  //     outAssetDest: context.orderNote.address,
-  //     outAmount: context.orderNote.amount,
-  //     feeRatio: context.orderNote.feeRatio,
-  //     inNote: hexlify32(context.swapInNote.note),
-  //     inNoteFooter: context.proof.swapInNoteFooter,
-  //     destContractAddress: this._darkSwapOfDestChain.contracts.synaraDarkSwapOnBridgeAssetManager,
-  //   };
-  //   // const callData = this._assemblyCallData(args, attestationDetails);
-  //   return callData;
-  // }
-  ;
-  _proto.allowance =
-  /*#__PURE__*/
-  function () {
-    var _allowance = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(context) {
-      var signer, asset, amount, allowanceContract, allowance, isLegacy, contract, tx;
-      return _regenerator().w(function (_context3) {
-        while (1) switch (_context3.n) {
-          case 0:
-            if (!(!context || !context.orderNote || !context.address || !context.signature || !context.proof)) {
-              _context3.n = 1;
-              break;
-            }
-            throw new DarkSwapError('Invalid context');
-          case 1:
-            signer = this._darkSwapOfSourceChain.signer;
-            asset = context.orderNote.asset;
-            amount = context.orderNote.amount;
-            allowanceContract = new ethers.ethers.Contract(asset, ERC20Abi.abi, this._darkSwapOfSourceChain);
-            _context3.n = 2;
-            return allowanceContract.allowance(signer.getAddress(), this._darkSwapOfSourceChain.contracts.darkSwapAssetManager);
-          case 2:
-            allowance = _context3.v;
-            if (!(BigInt(allowance) < amount)) {
-              _context3.n = 4;
-              break;
-            }
-            isLegacy = legacyTokenConfig.hasOwnProperty(this._darkSwapOfSourceChain.chainId) && legacyTokenConfig[this._darkSwapOfSourceChain.chainId].includes(asset.toLowerCase());
-            contract = new ethers.ethers.Contract(asset, isLegacy ? ERC20_USDT.abi : ERC20Abi.abi, signer);
-            _context3.n = 3;
-            return contract.approve(this._darkSwapOfSourceChain.contracts.darkSwapAssetManager, hexlify32(MAX_ALLOWANCE));
-          case 3:
-            tx = _context3.v;
-            _context3.n = 4;
-            return tx.wait();
-          case 4:
-            return _context3.a(2);
-        }
-      }, _callee3, this);
+var noir_version$a = "1.0.0-beta.6+e796dfd67726cbc28eb9991782533b211025928d";
+var hash$a = "10316634211613751299";
+var abi$f = {
+	parameters: [
+		{
+			name: "dest_chain",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "bridge_fee_amount",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "address",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "deposit_out_note",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "deposit_out_note_footer",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "deposit_out_rho",
+			type: {
+				kind: "field"
+			},
+			visibility: "private"
+		},
+		{
+			name: "out_asset_a",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "out_asset_b",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "out_amount",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "in_asset",
+			type: {
+				kind: "field"
+			},
+			visibility: "private"
+		},
+		{
+			name: "in_amount",
+			type: {
+				kind: "field"
+			},
+			visibility: "private"
+		},
+		{
+			name: "fee_ratio",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "fee_amount",
+			type: {
+				kind: "field"
+			},
+			visibility: "private"
+		},
+		{
+			name: "in_note",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "in_note_footer",
+			type: {
+				kind: "field"
+			},
+			visibility: "public"
+		},
+		{
+			name: "in_rho",
+			type: {
+				kind: "field"
+			},
+			visibility: "private"
+		},
+		{
+			name: "pub_key",
+			type: {
+				kind: "array",
+				length: 2,
+				type: {
+					kind: "field"
+				}
+			},
+			visibility: "private"
+		},
+		{
+			name: "signature",
+			type: {
+				kind: "array",
+				length: 64,
+				type: {
+					kind: "integer",
+					sign: "unsigned",
+					width: 8
+				}
+			},
+			visibility: "private"
+		}
+	],
+	return_type: null,
+	error_types: {
+		"6485997221020871071": {
+			error_kind: "string",
+			string: "call to assert_max_bit_size"
+		},
+		"14225679739041873922": {
+			error_kind: "string",
+			string: "Index out of bounds"
+		},
+		"17843811134343075018": {
+			error_kind: "string",
+			string: "Stack too deep"
+		}
+	}
+};
+var bytecode$f = "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";
+var debug_symbols$a = "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";
+var file_map$a = {
+	"16": {
+		source: "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n        let point1_1 = EmbeddedCurvePoint {\n            x: point1.x + (x_coordinates_match as Field),\n            y: point1.y,\n            is_infinite: false,\n        };\n        let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n        // point1_1 is guaranteed to have a different abscissa than point2:\n        // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n        // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n        // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n        // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n        let mut result = embedded_curve_add_unsafe(point1_1, point2_1);\n\n        // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n        let double = embedded_curve_add_unsafe(point1, point1);\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        result = if double_predicate { double } else { result };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2)[0]\n}\n",
+		path: "std/embedded_curve_ops.nr"
+	},
+	"17": {
+		source: "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n",
+		path: "std/field/bn254.nr"
+	},
+	"18": {
+		source: "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n",
+		path: "std/field/mod.nr"
+	},
+	"19": {
+		source: "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n    let mut sum = 0;\n\n    for input in inputs {\n        let input_bytes: [u8; 32] = input.to_le_bytes();\n        sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n    }\n\n    sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher<H>\nwhere\n    H: Hasher,\n{\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher<H> for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n",
+		path: "std/hash/mod.nr"
+	},
+	"50": {
+		source: "use dep::fuzk;\nuse mimc::mimc_bn254;\nuse schnorr::verify_signature;\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::field::bn254::assert_gt;\n\n\n#[export]\nfn main(\n    dest_chain: pub Field,\n    //deposit_id: pub Field,\n    //bridge fee\n    bridge_fee_amount: pub Field,\n\n    address: pub Field,\n\n    deposit_out_note: pub Field,\n    deposit_out_note_footer: pub Field,\n    deposit_out_rho: Field,\n\n    //order\n    out_asset_a: pub Field,\n    out_asset_b: pub Field,\n    out_amount: pub Field,\n    in_asset: Field,\n    in_amount: Field,\n\n    //fee\n    fee_ratio: pub Field,\n    fee_amount: Field,\n\n    //swap in \n    in_note: pub Field,\n    in_note_footer: pub Field,\n    in_rho: Field,\n\n    pub_key: [Field; 2],\n    signature: [u8; 64]\n) {\n    let precision: Field = 1000000;\n    let fee_ratio_zero:Field = 0;\n\n    assert_gt(out_amount, bridge_fee_amount);\n\n    if (fee_amount * precision != in_amount * fee_ratio) {\n        assert_gt(fee_amount * precision, in_amount * fee_ratio);\n    }\n    //assert (fee_amount == in_amount * fee_ratio / precision);\n    assert_gt(in_amount, fee_amount);\n    \n    let slice: [Field] = &[in_amount, fee_amount];   \n    let mut amounts = Vec::from_slice(slice);\n    fuzk::assert_amounts(&mut amounts);\n\n\n    fuzk::assert_note(\n        deposit_out_note,\n        address,\n        out_asset_b,\n        out_amount - bridge_fee_amount,\n        deposit_out_rho,\n        fee_ratio,\n        pub_key,\n        Option::some(3),\n        true\n    );\n    \n    //fuzk::assert_nullifier(deposit_out_nullifier,deposit_out_rho,pub_key,);\n\n    fuzk::assert_note_footer(deposit_out_note_footer, deposit_out_rho, pub_key);\n    \n    fuzk::assert_note(\n        in_note,\n        address,\n        in_asset,\n        in_amount - fee_amount,\n        in_rho,\n        fee_ratio_zero,\n        pub_key,\n        Option::some(2),\n        false\n    );\n    \n    fuzk::assert_note_footer(in_note_footer, in_rho, pub_key);\n\n    let signature_domain = 20003;\n\n    let m = mimc_bn254([\n        signature_domain,\n        //deposit_id,\n        dest_chain,\n        address,\n        out_asset_a,\n        deposit_out_note,\n        fee_ratio,\n        in_note\n    ]);\n\n    let m_bytes = fuzk::to_bytes(m);\n\n    let pub_key_point: EmbeddedCurvePoint = EmbeddedCurvePoint { x: pub_key[0], y: pub_key[1], is_infinite: false };\n    let v = verify_signature(pub_key_point, signature, m_bytes);\n\n    assert(v);\n}\n",
+		path: "/Users/wenjie/Work/Singularity/git/darkSwap-zk-contracts/circuits/synara_dark_swap_retail_deposit_bridge_create_order/src/main.nr"
+	},
+	"51": {
+		source: "use dep::std;\nuse mimc::mimc_bn254;\nuse std::field::bn254::assert_gt;\n\npub fn assert_amounts(amounts: &mut Vec<Field>) {\n    let amounts_size = amounts.len();\n    for _ in 0..amounts_size {\n        let amount = amounts.pop();\n        if (amount != 0){\n            amount.assert_max_bit_size::<252>();\n            assert_gt(amount, 0);\n        }\n    }\n}\n\npub fn to_bytes(x: Field) -> [u8; 32] {\n    x.to_le_bytes::<32>()\n}\n\npub fn note_footer(rho: Field, pub_key: [Field; 2]) -> Field {\n    mimc_bn254(\n        [\n        mimc_bn254([rho]),\n        pub_key[0],\n        pub_key[1]\n    ]\n    )\n}\n\n\npub fn assert_note(\n    note: Field,\n    address: Field,\n    asset: Field,\n    amount: Field,\n    rho: Field,\n    fee_ratio: Field,\n    pub_key: [Field; 2],\n    note_domain_separator: Option<Field>,\n    is_order: bool\n) {\n    assert_note_with_footer(\n        note,\n        address,\n        asset,\n        amount,\n        fee_ratio,\n        note_footer(rho, pub_key),\n        note_domain_separator,\n        is_order\n    )\n}\n\npub fn assert_note_footer(in_note_footer: Field, rho: Field, pub_key: [Field; 2]) {\n    assert(in_note_footer == note_footer(rho, pub_key));\n}\n\npub fn assert_note_with_footer(\n    note: Field,\n    address: Field,\n    asset: Field,\n    amount: Field,\n    fee_ratio: Field,\n    footer: Field,\n    note_domain_separator: Option<Field>,\n    is_order:bool\n) {\n    assert(\n        note == \n            if is_order {\n                mimc_bn254([\n                    note_domain_separator.unwrap(),\n                    address,\n                    asset,\n                    amount,\n                    fee_ratio,\n                    footer\n                ])\n            } else {\n                mimc_bn254([\n                    note_domain_separator.unwrap(),\n                    address,\n                    asset,\n                    amount,\n                    footer\n                ])\n            }\n         );\n}\n\npub fn assert_note_with_membership(\n    merkle_root: Field,\n    merkle_index: [u1; 32],\n    merkle_path: [Field; 32],\n    address: Field,\n    note: Field,\n    asset: Field,\n    amount: Field,\n    rho: Field,\n    fee_ratio: Field,\n    pub_key: [Field; 2],\n    note_domain_separator: Option<Field>,\n    is_order:bool\n) {\n    assert_note(note,address,asset, amount, rho, fee_ratio,pub_key, note_domain_separator, is_order);\n    assert(merkle_root == compute_merkle_root(note, merkle_index, merkle_path));\n}\n\npub fn assert_nullifier(nullifier: Field, rho: Field, pub_key: [Field; 2]) {\n    assert(\n        nullifier == mimc_bn254(\n            [\n            rho,\n            pub_key[0],\n            pub_key[1]\n        ]\n        )\n    );\n}\n\npub fn compute_merkle_root(leaf: Field, merkle_index: [u1; 32], merkle_path: [Field; 32]) -> Field {\n    \n    let mut merkle_root = mimc_bn254([0x0, leaf]);\n    for i in 0..32 {\n        let left = if merkle_index[i] == 0 {\n            merkle_root\n        } else {\n            merkle_path[i]\n        };\n        let right = if merkle_index[i] == 1 {\n            merkle_root\n        } else {\n            merkle_path[i]\n        };\n\n        let next_merkle_root = mimc_bn254([0x01, left, right]);\n\n        if merkle_path[i] != 0 {\n            merkle_root = next_merkle_root;\n        }\n    }\n    merkle_root\n}\n\n#[test]\nfn test_assert_amounts() {\n    let amount_1: Field = 1;\n    let amount_2: Field = 2;\n\n    let slice: [Field] = &[amount_1, amount_2];\n    let mut amounts = Vec::from_slice(slice);\n\n    assert_amounts(&mut amounts);\n}\n\n#[test(should_fail)]\nfn test_assert_amounts_fail() {\n    let amount_1: Field = 1;\n    let amount_2: Field = -2;\n    let amount_3: Field = -3;\n\n    let slice: [Field] = &[amount_1, amount_2, amount_3];\n    let mut amounts = Vec::from_slice(slice);\n\n    assert_amounts(&mut amounts);\n}\n",
+		path: "/Users/wenjie/Work/Singularity/git/darkSwap-zk-contracts/circuits/fuzk/src/lib.nr"
+	},
+	"52": {
+		source: "use std::hash::Hasher;\nuse std::default::Default;\n\n// mimc-p/p implementation\n// constants are (publicly generated) random numbers, for instance using keccak as a ROM.\n// You must use constants generated for the native field\n// Rounds number should be ~ log(p)/log(exp)\n// For 254 bit primes, exponent 7 and 91 rounds seems to be recommended\npub fn mimc<let N: u32>(x: Field, k: Field, constants: [Field; N], exp: Field) -> Field {\n    //round 0\n    let mut t = x + k;\n    let mut h = t.pow_32(exp);\n    //next rounds\n    for i in 1..constants.len() {\n        t = h + k + constants[i];\n        h = t.pow_32(exp);\n    }\n    h + k\n}\n\nglobal MIMC_BN254_ROUNDS: u32 = 91;\n//generated from seed \"mimc\" using keccak256 \nglobal MIMC_BN254_CONSTANTS: [Field; MIMC_BN254_ROUNDS] = [\n        0,\n        20888961410941983456478427210666206549300505294776164667214940546594746570981,\n        15265126113435022738560151911929040668591755459209400716467504685752745317193,\n        8334177627492981984476504167502758309043212251641796197711684499645635709656,\n        1374324219480165500871639364801692115397519265181803854177629327624133579404,\n        11442588683664344394633565859260176446561886575962616332903193988751292992472,\n        2558901189096558760448896669327086721003508630712968559048179091037845349145,\n        11189978595292752354820141775598510151189959177917284797737745690127318076389,\n        3262966573163560839685415914157855077211340576201936620532175028036746741754,\n        17029914891543225301403832095880481731551830725367286980611178737703889171730,\n        4614037031668406927330683909387957156531244689520944789503628527855167665518,\n        19647356996769918391113967168615123299113119185942498194367262335168397100658,\n        5040699236106090655289931820723926657076483236860546282406111821875672148900,\n        2632385916954580941368956176626336146806721642583847728103570779270161510514,\n        17691411851977575435597871505860208507285462834710151833948561098560743654671,\n        11482807709115676646560379017491661435505951727793345550942389701970904563183,\n        8360838254132998143349158726141014535383109403565779450210746881879715734773,\n        12663821244032248511491386323242575231591777785787269938928497649288048289525,\n        3067001377342968891237590775929219083706800062321980129409398033259904188058,\n        8536471869378957766675292398190944925664113548202769136103887479787957959589,\n        19825444354178182240559170937204690272111734703605805530888940813160705385792,\n        16703465144013840124940690347975638755097486902749048533167980887413919317592,\n        13061236261277650370863439564453267964462486225679643020432589226741411380501,\n        10864774797625152707517901967943775867717907803542223029967000416969007792571,\n        10035653564014594269791753415727486340557376923045841607746250017541686319774,\n        3446968588058668564420958894889124905706353937375068998436129414772610003289,\n        4653317306466493184743870159523234588955994456998076243468148492375236846006,\n        8486711143589723036499933521576871883500223198263343024003617825616410932026,\n        250710584458582618659378487568129931785810765264752039738223488321597070280,\n        2104159799604932521291371026105311735948154964200596636974609406977292675173,\n        16313562605837709339799839901240652934758303521543693857533755376563489378839,\n        6032365105133504724925793806318578936233045029919447519826248813478479197288,\n        14025118133847866722315446277964222215118620050302054655768867040006542798474,\n        7400123822125662712777833064081316757896757785777291653271747396958201309118,\n        1744432620323851751204287974553233986555641872755053103823939564833813704825,\n        8316378125659383262515151597439205374263247719876250938893842106722210729522,\n        6739722627047123650704294650168547689199576889424317598327664349670094847386,\n        21211457866117465531949733809706514799713333930924902519246949506964470524162,\n        13718112532745211817410303291774369209520657938741992779396229864894885156527,\n        5264534817993325015357427094323255342713527811596856940387954546330728068658,\n        18884137497114307927425084003812022333609937761793387700010402412840002189451,\n        5148596049900083984813839872929010525572543381981952060869301611018636120248,\n        19799686398774806587970184652860783461860993790013219899147141137827718662674,\n        19240878651604412704364448729659032944342952609050243268894572835672205984837,\n        10546185249390392695582524554167530669949955276893453512788278945742408153192,\n        5507959600969845538113649209272736011390582494851145043668969080335346810411,\n        18177751737739153338153217698774510185696788019377850245260475034576050820091,\n        19603444733183990109492724100282114612026332366576932662794133334264283907557,\n        10548274686824425401349248282213580046351514091431715597441736281987273193140,\n        1823201861560942974198127384034483127920205835821334101215923769688644479957,\n        11867589662193422187545516240823411225342068709600734253659804646934346124945,\n        18718569356736340558616379408444812528964066420519677106145092918482774343613,\n        10530777752259630125564678480897857853807637120039176813174150229243735996839,\n        20486583726592018813337145844457018474256372770211860618687961310422228379031,\n        12690713110714036569415168795200156516217175005650145422920562694422306200486,\n        17386427286863519095301372413760745749282643730629659997153085139065756667205,\n        2216432659854733047132347621569505613620980842043977268828076165669557467682,\n        6309765381643925252238633914530877025934201680691496500372265330505506717193,\n        20806323192073945401862788605803131761175139076694468214027227878952047793390,\n        4037040458505567977365391535756875199663510397600316887746139396052445718861,\n        19948974083684238245321361840704327952464170097132407924861169241740046562673,\n        845322671528508199439318170916419179535949348988022948153107378280175750024,\n        16222384601744433420585982239113457177459602187868460608565289920306145389382,\n        10232118865851112229330353999139005145127746617219324244541194256766741433339,\n        6699067738555349409504843460654299019000594109597429103342076743347235369120,\n        6220784880752427143725783746407285094967584864656399181815603544365010379208,\n        6129250029437675212264306655559561251995722990149771051304736001195288083309,\n        10773245783118750721454994239248013870822765715268323522295722350908043393604,\n        4490242021765793917495398271905043433053432245571325177153467194570741607167,\n        19596995117319480189066041930051006586888908165330319666010398892494684778526,\n        837850695495734270707668553360118467905109360511302468085569220634750561083,\n        11803922811376367215191737026157445294481406304781326649717082177394185903907,\n        10201298324909697255105265958780781450978049256931478989759448189112393506592,\n        13564695482314888817576351063608519127702411536552857463682060761575100923924,\n        9262808208636973454201420823766139682381973240743541030659775288508921362724,\n        173271062536305557219323722062711383294158572562695717740068656098441040230,\n        18120430890549410286417591505529104700901943324772175772035648111937818237369,\n        20484495168135072493552514219686101965206843697794133766912991150184337935627,\n        19155651295705203459475805213866664350848604323501251939850063308319753686505,\n        11971299749478202793661982361798418342615500543489781306376058267926437157297,\n        18285310723116790056148596536349375622245669010373674803854111592441823052978,\n        7069216248902547653615508023941692395371990416048967468982099270925308100727,\n        6465151453746412132599596984628739550147379072443683076388208843341824127379,\n        16143532858389170960690347742477978826830511669766530042104134302796355145785,\n        19362583304414853660976404410208489566967618125972377176980367224623492419647,\n        1702213613534733786921602839210290505213503664731919006932367875629005980493,\n        10781825404476535814285389902565833897646945212027592373510689209734812292327,\n        4212716923652881254737947578600828255798948993302968210248673545442808456151,\n        7594017890037021425366623750593200398174488805473151513558919864633711506220,\n        18979889247746272055963929241596362599320706910852082477600815822482192194401,\n        13602139229813231349386885113156901793661719180900395818909719758150455500533\n    ];\n\n//mimc implementation with hardcoded parameters for BN254 curve.\n#[field(bn254)]\npub fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field {\n    let exponent = 7;\n    let mut r = 0;\n    for elem in array {\n        let h = mimc(elem, r, MIMC_BN254_CONSTANTS, exponent);\n        r = r + elem + h;\n    }\n    r\n}\n\npub struct MimcHasher {\n    _state: [Field],\n}\n\nimpl Hasher for MimcHasher {\n    #[field(bn254)]\n    fn finish(self) -> Field {\n        let exponent = 7;\n        let mut r = 0;\n        for i in 0..self._state.len() {\n            let h = mimc(self._state[i], r, MIMC_BN254_CONSTANTS, exponent);\n            r = r + self._state[i] + h;\n        }\n        r\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for MimcHasher {\n    fn default() -> Self {\n        MimcHasher { _state: &[] }\n    }\n}\n\nmod tests {\n    use super::mimc_bn254;\n\n    #[test]\n    fn smoke_test() {\n        let input = [12, 45, 78, 41];\n        let expected_output = 18226366069841799622585958305961373004333097209608110160936134895615261821931;\n        assert_eq(mimc_bn254(input), expected_output);\n    }\n}\n",
+		path: "/Users/wenjie/nargo/github.com/noir-lang/mimc/v0.1.0/src/lib.nr"
+	},
+	"53": {
+		source: "use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};\nuse std::hash::{blake2s, pedersen_hash};\n\n// the multiples of BN_P that are still less than 2^254 split into (lo, hi)\nglobal BN_P_m: [(Field, Field); 6] = [\n    (0, 0),\n    (201385395114098847380338600778089168199, 64323764613183177041862057485226039389),\n    (62488423307259231297302594124410124942, 128647529226366354083724114970452078779),\n    (263873818421358078677641194902499293141, 192971293839549531125586172455678118168),\n    (124976846614518462594605188248820249884, 257295058452732708167448229940904157558),\n    (326362241728617309974943789026909418083, 321618823065915885209310287426130196947),\n];\n\nglobal TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let reduced_sig_e = normalize_signature(sig_e);\n    let r = multi_scalar_mul([g1, public_key], [sig_s, reduced_sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\nunconstrained fn __gt(a: Field, b: Field) -> bool {\n    b.lt(a)\n}\n\n// gets the quotient of lo/hi when divided by BN254_Fq modulus\nunconstrained fn __get_quotient(hi: Field, lo: Field) -> Field {\n    let mut q: Field = 0;\n    let mut r_hi = hi;\n    let mut r_lo = lo;\n    let MODULUS = BN_P_m[1];\n\n    for _ in 1..6 {\n        // check if rhi, rlo is larger than BN_P\n        let borrow = r_lo.lt(MODULUS.0);\n\n        if borrow {\n            r_lo = r_lo + TWO_POW_128;\n            // rlo is always larger than BN_P lo now\n            r_hi = r_hi - 1;\n        }\n\n        let MODULUS_hi = MODULUS.1;\n\n        let gt_flag = !r_hi.lt(MODULUS_hi);\n\n        if gt_flag {\n            r_hi = r_hi - MODULUS.1;\n            r_lo = r_lo - MODULUS.0;\n            if TWO_POW_128.lt(r_lo) | TWO_POW_128.lt(r_hi) {\n                break;\n            }\n            q += 1;\n        }\n    }\n    q\n}\n\n// this method reduces the signature to the range [0, BN254_Fq_MODULUS)\nfn normalize_signature(sig_e: EmbeddedCurveScalar) -> EmbeddedCurveScalar {\n    let mut hi = sig_e.hi;\n    let mut lo = sig_e.lo;\n    // get the quotient\n    let q = unsafe { __get_quotient(hi, lo) };\n    let MODULUSmq = (BN_P_m[q].0, BN_P_m[q].1);\n    let MODULUS = BN_P_m[1];\n    // remove MODULUS * q from lo/hi\n    let borrow = unsafe { __gt(MODULUSmq.0, lo) };\n    // rlo, rhi is the signature without the multiple of MODULUS\n    let rlo = lo - MODULUSmq.0 + borrow as Field * TWO_POW_128;\n    let rhi = hi - borrow as Field - MODULUSmq.1;\n    // now we validate that rlo and rhi are positive\n    rlo.assert_max_bit_size::<128>();\n    rhi.assert_max_bit_size::<128>();\n    // validate that rlo, rhi is smaller than MODULUS\n    // if the lo is larger than the modulus lo we have to get a borrow\n    let borrow = unsafe { __gt(rlo, MODULUS.0) };\n    let rplo = MODULUS.0 - rlo + borrow as Field * TWO_POW_128;\n    let rphi = MODULUS.1 - rhi - borrow as Field;\n    // check that rplo and rphi are positive\n    rplo.assert_max_bit_size::<128>();\n    rphi.assert_max_bit_size::<128>();\n    EmbeddedCurveScalar::new(rlo, rhi)\n}\n\n//Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\nfn scalar_from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n    let mut v: Field = 1;\n    let mut lo: Field = 0;\n    let mut hi: Field = 0;\n    for i in 0..16 {\n        lo = lo + (bytes[offset + 31 - i] as Field) * v;\n        hi = hi + (bytes[offset + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    let sig_s = EmbeddedCurveScalar::new(lo, hi);\n    sig_s\n}\n\nmod test {\n    use super::normalize_signature;\n    use super::verify_signature;\n    use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar};\n\n    #[test]\n    fn test_zero_signature() {\n        let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860,\n            is_infinite: false,\n        };\n        let signature: [u8; 64] = [0; 64];\n        let message: [u8; _] = [2; 64]; // every message\n        let verified = verify_signature(public_key, signature, message);\n        assert(!verified);\n    }\n\n    #[test]\n    fn smoke_test() {\n        let message: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n        let pub_key_x: Field = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;\n        let pub_key_y: Field = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;\n        let signature: [u8; 64] = [\n            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,\n            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84,\n            247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64,\n            199, 19, 84, 239, 138, 124, 12,\n        ];\n\n        let pub_key = EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };\n        let valid_signature = verify_signature(pub_key, signature, message);\n        assert(valid_signature);\n        super::assert_valid_signature(pub_key, signature, message);\n    }\n\n    #[test]\n    fn test_normalize_signature() {\n        let sig_e = EmbeddedCurveScalar::new(\n            201385395114098847380338600778112493540,\n            64323764613183177041862057485226039389,\n        );\n        let normalized = normalize_signature(sig_e);\n        let expected = EmbeddedCurveScalar::new(23325341, 0);\n        assert(normalized == expected);\n    }\n\n    #[test]\n    fn test_normalize_signature_2() {\n        let sig_e = EmbeddedCurveScalar::new(\n            263873818421358078677641194902522618482,\n            192971293839549531125586172455678118168,\n        );\n        let normalized = normalize_signature(sig_e);\n        let expected = EmbeddedCurveScalar::new(23325341, 0);\n        assert(normalized == expected);\n    }\n\n}\n\nmod bench {\n    use super::{assert_valid_signature, verify_signature};\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    #[export]\n    pub fn bench_verify_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) -> bool {\n        verify_signature(public_key, signature, message)\n    }\n\n    #[export]\n    pub fn bench_assert_valid_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) {\n        assert_valid_signature(public_key, signature, message)\n    }\n}\n\n",
+		path: "/Users/wenjie/nargo/github.com/noir-lang/schnorr/v0.1.2/src/lib.nr"
+	}
+};
+var names$a = [
+	"main"
+];
+var brillig_names$a = [
+	"decompose_hint",
+	"lte_hint",
+	"__get_quotient",
+	"__gt",
+	"directive_invert",
+	"directive_to_radix",
+	"directive_integer_quotient"
+];
+var retailBridgeOrderCircuit = {
+	noir_version: noir_version$a,
+	hash: hash$a,
+	abi: abi$f,
+	bytecode: bytecode$f,
+	debug_symbols: debug_symbols$a,
+	file_map: file_map$a,
+	names: names$a,
+	brillig_names: brillig_names$a
+};
+function generateRetailBridgeOrderProof(_x) {
+  return _generateRetailBridgeOrderProof.apply(this, arguments);
+}
+function _generateRetailBridgeOrderProof() {
+  _generateRetailBridgeOrderProof = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(param) {
+    var _yield$generateKeyPai, _yield$generateKeyPai2, fuzkPubKeyX, fuzkPubKeyY, fuzkPriKey, depositFooter, inAmount, swapInNoteFooter, addressMod, depositSourceAssetMod, message, signature, inputs, proof;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          if (!(param.depositNote.amount <= 0n)) {
+            _context.n = 1;
+            break;
+          }
+          throw new DarkSwapProofError("Deposit amount must be greater than 0");
+        case 1:
+          if (!(param.depositNote.feeRatio < 0n)) {
+            _context.n = 2;
+            break;
+          }
+          throw new DarkSwapProofError("Fee ratio must be greater or equal to 0");
+        case 2:
+          _context.n = 3;
+          return generateKeyPair(param.signedMessage);
+        case 3:
+          _yield$generateKeyPai = _context.v;
+          _yield$generateKeyPai2 = _yield$generateKeyPai[0];
+          fuzkPubKeyX = _yield$generateKeyPai2[0];
+          fuzkPubKeyY = _yield$generateKeyPai2[1];
+          fuzkPriKey = _yield$generateKeyPai[1];
+          depositFooter = getNoteFooter(param.depositNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
+          inAmount = param.feeAmount + param.swapInNote.amount;
+          swapInNoteFooter = getNoteFooter(param.swapInNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
+          addressMod = encodeAddress(param.address);
+          depositSourceAssetMod = encodeAddress(param.depositSourceAsset);
+          message = bn_to_hex(mimc_bn254([BigInt(exports.PROOF_DOMAIN.RETAIL_BRIDGE_ORDER), BigInt(param.destChain), addressMod, depositSourceAssetMod, param.depositNote.note, param.depositNote.feeRatio, param.swapInNote.note]));
+          _context.n = 4;
+          return signMessage(message, fuzkPriKey);
+        case 4:
+          signature = _context.v;
+          inputs = {
+            address: bn_to_0xhex(addressMod),
+            dest_chain: bn_to_0xhex(BigInt(param.destChain)),
+            bridge_fee_amount: bn_to_0xhex(param.bridgeFeeAmount),
+            deposit_out_note: bn_to_0xhex(param.depositNote.note),
+            deposit_out_note_footer: bn_to_0xhex(depositFooter),
+            deposit_out_rho: bn_to_0xhex(param.depositNote.rho),
+            out_asset_a: bn_to_0xhex(depositSourceAssetMod),
+            out_asset_b: bn_to_0xhex(encodeAddress(param.depositNote.asset)),
+            out_amount: bn_to_0xhex(param.depositNote.amount + param.bridgeFeeAmount),
+            in_asset: bn_to_0xhex(encodeAddress(param.swapInNote.asset)),
+            in_amount: bn_to_0xhex(inAmount),
+            fee_ratio: bn_to_0xhex(param.feeRatio),
+            fee_amount: bn_to_0xhex(param.feeAmount),
+            in_note: bn_to_0xhex(param.swapInNote.note),
+            in_note_footer: bn_to_0xhex(swapInNoteFooter),
+            in_rho: bn_to_0xhex(param.swapInNote.rho),
+            pub_key: [fuzkPubKeyX.toString(), fuzkPubKeyY.toString()],
+            signature: uint8ArrayToNumberArray(signature)
+          };
+          _context.n = 5;
+          return generateProof(retailBridgeOrderCircuit, inputs);
+        case 5:
+          proof = _context.v;
+          return _context.a(2, _extends({}, proof, {
+            depositFooter: inputs.deposit_out_note_footer,
+            swapInNoteFooter: inputs.in_note_footer
+          }));
+      }
+    }, _callee);
+  }));
+  return _generateRetailBridgeOrderProof.apply(this, arguments);
+}
+var _VK_HASH_CONFIG;
+var VK_HASH_CONFIG = (_VK_HASH_CONFIG = {}, _VK_HASH_CONFIG[exports.PROOF_DOMAIN.RETAIL_BRIDGE_ORDER] = '0x0ca4f42da1fbc3e0f0b6b715f2b5458e41ff6c91f0a0c4b035cd64243c2661d6', _VK_HASH_CONFIG);
+var _format$5 = "hh-sol-artifact-1";
+var contractName$5 = "SynaraDarkSwapOnBridgeAssetManager";
+var sourceName$5 = "contracts/core/SynaraDarkSwapOnBridgeAssetManager.sol";
+var abi$g = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolERC20",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "assetPoolETH",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "verifierHub",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "darkSwapfeeManager",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "merkleTreeOperator",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "mimc254",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "bridge",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "canonicalTokenRegistry",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "initialOwner",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		inputs: [
+		],
+		name: "InvalidNoteParameters",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "MerkleRootNotAllowed",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteAlreadyCreated",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteFooterDuplicated",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteFooterUsed",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NullifierLocked",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NullifierUsed",
+		type: "error"
+	},
+	{
+		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"
+	},
+	{
+		inputs: [
+		],
+		name: "ZeroAddress",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "invalidArguments",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "depositCommitment",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "destContractAddress",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}
+		],
+		name: "DarkSwapRetailDepositBridge",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "depositCommitment",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "depositOutNote",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "depositOutNoteFooter",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "inNote",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "inNoteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "DarkSwapRetailDepositBridgeCreateOrder",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferred",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "ASSET_ETH",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "ETH_ADDRESS",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "P",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "SYNARA_DARK_SWAP_RETAIL_DEPOSIT_BRIDGE_CREATE_ORDER",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "noteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "_validateNoteFooterIsNotUsed",
+		outputs: [
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "noteCommitment",
+				type: "bytes32"
+			}
+		],
+		name: "_validateNoteIsNotCreated",
+		outputs: [
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "currentNonce",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getAssetPoolERC20",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getAssetPoolETH",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getBridge",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getCanonicalTokenRegistry",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getFeeManager",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getMerkleTreeOperator",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getMimc254",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getVerifierHub",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "depositCommitment",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "callData",
+				type: "bytes"
+			}
+		],
+		name: "receiveFromBridge",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "releaseToAsssetPool",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "renounceOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_depositCommitment",
+				type: "bytes32"
+			},
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "destChain",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "bridgeFee",
+						type: "uint256"
+					},
+					{
+						internalType: "address",
+						name: "owner",
+						type: "address"
+					},
+					{
+						internalType: "bytes32",
+						name: "depositOutNote",
+						type: "bytes32"
+					},
+					{
+						internalType: "bytes32",
+						name: "depositOutNoteFooter",
+						type: "bytes32"
+					},
+					{
+						internalType: "address",
+						name: "outAssetSource",
+						type: "address"
+					},
+					{
+						internalType: "address",
+						name: "outAssetDest",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "outAmount",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "feeRatio",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes32",
+						name: "inNote",
+						type: "bytes32"
+					},
+					{
+						internalType: "bytes32",
+						name: "inNoteFooter",
+						type: "bytes32"
+					},
+					{
+						internalType: "address",
+						name: "destContractAddress",
+						type: "address"
+					}
+				],
+				internalType: "struct SynaraDarkSwapOnBridgeAssetManager.RetailDepositBridgeCreateOrderArgs",
+				name: "_args",
+				type: "tuple"
+			},
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "attestationId",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes32[]",
+						name: "merklePath",
+						type: "bytes32[]"
+					},
+					{
+						internalType: "uint256",
+						name: "leafCount",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "index",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IZkvHub.AttestationDetails",
+				name: "_attDetails",
+				type: "tuple"
+			}
+		],
+		name: "retailDepositBridge",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolERC20",
+				type: "address"
+			}
+		],
+		name: "setAssetPoolERC20",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolETH",
+				type: "address"
+			}
+		],
+		name: "setAssetPoolETH",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "bridge",
+				type: "address"
+			}
+		],
+		name: "setBridge",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "canonicalTokenRegistry",
+				type: "address"
+			}
+		],
+		name: "setCanonicalTokenRegistry",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "feeManager",
+				type: "address"
+			}
+		],
+		name: "setFeeManager",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		stateMutability: "payable",
+		type: "receive"
+	}
+];
+var bytecode$g = "";
+var deployedBytecode$5 = "";
+var linkReferences$5 = {
+};
+var deployedLinkReferences$5 = {
+};
+var SynaraDarkSwapOnBridgeAssetManagerAbi = {
+	_format: _format$5,
+	contractName: contractName$5,
+	sourceName: sourceName$5,
+	abi: abi$g,
+	bytecode: bytecode$g,
+	deployedBytecode: deployedBytecode$5,
+	linkReferences: linkReferences$5,
+	deployedLinkReferences: deployedLinkReferences$5
+};
+var _DOMAIN_PREFIX = "0x191253796e6172614272696467654465706f7369740a";
+var BridgeCreateOrderContext = /*#__PURE__*/function (_BaseContext) {
+  function BridgeCreateOrderContext(signature) {
+    return _BaseContext.call(this, signature) || this;
+  }
+  _inheritsLoose(BridgeCreateOrderContext, _BaseContext);
+  return _createClass(BridgeCreateOrderContext, [{
+    key: "orderNote",
+    get: function get() {
+      return this._orderNote;
+    },
+    set: function set(orderNote) {
+      this._orderNote = orderNote;
+    }
+  }, {
+    key: "swapInNote",
+    get: function get() {
+      return this._swapInNote;
+    },
+    set: function set(swapInNote) {
+      this._swapInNote = swapInNote;
+    }
+  }, {
+    key: "feeAmount",
+    get: function get() {
+      return this._feeAmount;
+    },
+    set: function set(feeAmount) {
+      this._feeAmount = feeAmount;
+    }
+  }, {
+    key: "proof",
+    get: function get() {
+      return this._proof;
+    },
+    set: function set(proof) {
+      this._proof = proof;
+    }
+  }, {
+    key: "swapMessage",
+    get: function get() {
+      return this._swapMessage;
+    },
+    set: function set(swapMessage) {
+      this._swapMessage = swapMessage;
+    }
+  }, {
+    key: "sourceChainId",
+    get: function get() {
+      return this._sourceChainId;
+    },
+    set: function set(sourceChainId) {
+      this._sourceChainId = sourceChainId;
+    }
+  }, {
+    key: "destChainId",
+    get: function get() {
+      return this._destChainId;
+    },
+    set: function set(destChainId) {
+      this._destChainId = destChainId;
+    }
+  }, {
+    key: "sourceAsset",
+    get: function get() {
+      return this._sourceAsset;
+    },
+    set: function set(sourceAsset) {
+      this._sourceAsset = sourceAsset;
+    }
+  }, {
+    key: "sourceAmount",
+    get: function get() {
+      return this._sourceAmount;
+    },
+    set: function set(sourceAmount) {
+      this._sourceAmount = sourceAmount;
+    }
+  }, {
+    key: "bridgeFeeAmount",
+    get: function get() {
+      return this._bridgeFeeAmount;
+    },
+    set: function set(bridgeFeeAmount) {
+      this._bridgeFeeAmount = bridgeFeeAmount;
+    }
+  }, {
+    key: "depositId",
+    get: function get() {
+      return this._depositId;
+    },
+    set: function set(depositId) {
+      this._depositId = depositId;
+    }
+  }, {
+    key: "attestationDetails",
+    get: function get() {
+      return this._attestationDetails;
+    },
+    set: function set(attestationDetails) {
+      this._attestationDetails = attestationDetails;
+    }
+  }, {
+    key: "relayer",
+    get: function get() {
+      return this._relayer;
+    },
+    set: function set(relayer) {
+      this._relayer = relayer;
+    }
+  }, {
+    key: "jobId",
+    get: function get() {
+      return this._jobId;
+    },
+    set: function set(jobId) {
+      this._jobId = jobId;
+    }
+  }, {
+    key: "canonicalId",
+    get: function get() {
+      return this._canonicalId;
+    },
+    set: function set(canonicalId) {
+      this._canonicalId = canonicalId;
+    }
+  }, {
+    key: "callDataHash",
+    get: function get() {
+      return this._callDataHash;
+    },
+    set: function set(callDataHash) {
+      this._callDataHash = callDataHash;
+    }
+  }, {
+    key: "nonce",
+    get: function get() {
+      return this._nonce;
+    },
+    set: function set(nonce) {
+      this._nonce = nonce;
+    }
+  }, {
+    key: "callData",
+    get: function get() {
+      return this._callData;
+    },
+    set: function set(callData) {
+      this._callData = callData;
+    }
+  }]);
+}(BaseContext);
+var BridgeCreateOrderService = /*#__PURE__*/function () {
+  function BridgeCreateOrderService(_darkSwapOfSourceChain, _darkSwapOfDestChain) {
+    this._darkSwapOfSourceChain = _darkSwapOfSourceChain;
+    this._darkSwapOfDestChain = _darkSwapOfDestChain;
+  }
+  var _proto = BridgeCreateOrderService.prototype;
+  _proto.prepare = /*#__PURE__*/function () {
+    var _prepare = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(address, sourceChainId, sourceAsset, sourceAmount, canonicalId, bridgeFee, destChainId, depositAsset, depositAmount, swapInAsset, swapInAmount, signature) {
+      var _yield$generateKeyPai, pubKey, privKey, feeRatio, orderNote, feeAmount, realSwapInAmount, swapInNote, context, swapMessage, _t, _t2;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            _context.n = 1;
+            return generateKeyPair(signature);
+          case 1:
+            _yield$generateKeyPai = _context.v;
+            pubKey = _yield$generateKeyPai[0];
+            privKey = _yield$generateKeyPai[1];
+            _t = BigInt;
+            _context.n = 2;
+            return getFeeRatio(address, this._darkSwapOfDestChain);
+          case 2:
+            _t2 = _context.v;
+            feeRatio = _t(_t2);
+            orderNote = createOrderNoteExt(address, depositAsset, depositAmount, feeRatio, pubKey);
+            feeAmount = calcFeeAmount(swapInAmount, feeRatio);
+            realSwapInAmount = swapInAmount - feeAmount;
+            swapInNote = createNote(address, swapInAsset, realSwapInAmount, pubKey);
+            context = new BridgeCreateOrderContext(signature);
+            context.orderNote = orderNote;
+            context.swapInNote = swapInNote;
+            context.feeAmount = feeAmount;
+            context.address = address;
+            context.sourceChainId = sourceChainId;
+            context.destChainId = destChainId;
+            context.sourceAsset = sourceAsset;
+            context.sourceAmount = sourceAmount;
+            context.bridgeFeeAmount = bridgeFee;
+            context.canonicalId = canonicalId;
+            _context.n = 3;
+            return generateRetailSwapMessage(address, orderNote, swapInNote, feeAmount, pubKey, privKey);
+          case 3:
+            swapMessage = _context.v;
+            context.swapMessage = swapMessage;
+            return _context.a(2, {
+              context: context,
+              swapMessage: swapMessage
+            });
+        }
+      }, _callee, this);
+    }));
+    function prepare(_x, _x2, _x3, _x4, _x5, _x6, _x7, _x8, _x9, _x0, _x1, _x10) {
+      return _prepare.apply(this, arguments);
+    }
+    return prepare;
+  }();
+  _proto.pickRelayer = function pickRelayer() {
+    return this._darkSwapOfSourceChain.contracts.zkverifyRelayerUrls[0];
+  };
+  _proto.submitProof = /*#__PURE__*/function () {
+    var _submitProof = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(context) {
+      var relayerRequest, response, _yield$this$pollJobSt, error, result;
+      return _regenerator().w(function (_context2) {
+        while (1) switch (_context2.n) {
+          case 0:
+            if (context) {
+              _context2.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            _context2.n = 2;
+            return this.generateProof(context);
+          case 2:
+            context.proof = _context2.v;
+            relayerRequest = {
+              proof: context.proof.proof,
+              publicSignals: context.proof.verifyInputs,
+              vkHash: VK_HASH_CONFIG[exports.PROOF_DOMAIN.RETAIL_BRIDGE_ORDER]
+            };
+            context.relayer = this.pickRelayer();
+            _context2.n = 3;
+            return axios.post(context.relayer + '/v1/zkVerifySubmitProof', relayerRequest);
+          case 3:
+            response = _context2.v;
+            if (!(response.status == 200)) {
+              _context2.n = 4;
+              break;
+            }
+            context.jobId = response.data.id;
+            _context2.n = 6;
+            break;
+          case 4:
+            if (!(response.status == 400)) {
+              _context2.n = 5;
+              break;
+            }
+            throw new Error('Request error' + response.data.error);
+          case 5:
+            throw new Error('Relayer not asscessable');
+          case 6:
+            _context2.n = 7;
+            return this.pollJobStatus(context);
+          case 7:
+            _yield$this$pollJobSt = _context2.v;
+            error = _yield$this$pollJobSt.error;
+            result = _yield$this$pollJobSt.result;
+            if (!error) {
+              _context2.n = 8;
+              break;
+            }
+            throw new DarkSwapError(error);
+          case 8:
+            context.attestationDetails = result;
+          case 9:
+            return _context2.a(2);
+        }
+      }, _callee2, this);
+    }));
+    function submitProof(_x11) {
+      return _submitProof.apply(this, arguments);
+    }
+    return submitProof;
+  }();
+  _proto.pollJobStatus = /*#__PURE__*/function () {
+    var _pollJobStatus = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(context) {
+      var tries, response, error, _response$data, status, failedReason, result, _t3;
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.n) {
+          case 0:
+            tries = 1;
+          case 1:
+            if (!(tries <= 100)) {
+              _context3.n = 10;
+              break;
+            }
+            if (!(tries >= 100)) {
+              _context3.n = 2;
+              break;
+            }
+            return _context3.a(3, 10);
+          case 2:
+            _context3.p = 2;
+            _context3.n = 3;
+            return axios.get(context.relayer + "/v1/jobs/" + context.jobId);
+          case 3:
+            response = _context3.v;
+            if (!(response.status === 400)) {
+              _context3.n = 4;
+              break;
+            }
+            error = response.data.error;
+            console.log(error);
+            return _context3.a(2, {
+              error: 'Failed to submit proof to relayer:' + error,
+              result: undefined
+            });
+          case 4:
+            if (!(response.status === 200)) {
+              _context3.n = 6;
+              break;
+            }
+            _response$data = response.data, status = _response$data.status, failedReason = _response$data.failedReason, result = _response$data.result;
+            if (!(status === 'FAILED')) {
+              _context3.n = 5;
+              break;
+            }
+            return _context3.a(2, {
+              error: failedReason != null ? failedReason : 'Transaction failed.',
+              result: undefined
+            });
+          case 5:
+            if (!(status === 'CONFIRMED' || status === 'MINED')) {
+              _context3.n = 6;
+              break;
+            }
+            return _context3.a(2, {
+              error: undefined,
+              result: {
+                attestationId: BigInt(result.attestationId),
+                merklePath: result.merklePath,
+                leafCount: BigInt(result.leafCount),
+                index: BigInt(result.index)
+              }
+            });
+          case 6:
+            _context3.n = 7;
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, 5000);
+            });
+          case 7:
+            _context3.n = 9;
+            break;
+          case 8:
+            _context3.p = 8;
+            _t3 = _context3.v;
+            console.log(_t3);
+          case 9:
+            tries++;
+            _context3.n = 1;
+            break;
+          case 10:
+            return _context3.a(2, {
+              error: 'Waited too long for getting attestation details.',
+              result: undefined
+            });
+        }
+      }, _callee3, null, [[2, 8]]);
+    }));
+    function pollJobStatus(_x12) {
+      return _pollJobStatus.apply(this, arguments);
+    }
+    return pollJobStatus;
+  }();
+  _proto.generateProof = /*#__PURE__*/function () {
+    var _generateProof = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(context) {
+      var proof;
+      return _regenerator().w(function (_context4) {
+        while (1) switch (_context4.n) {
+          case 0:
+            if (!(!context || !context.orderNote || !context.swapInNote || !context.address || context.feeAmount === undefined || !context.signature || !context.sourceChainId || !context.destChainId || !context.sourceAsset || !context.sourceAmount || context.bridgeFeeAmount === undefined)) {
+              _context4.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            _context4.n = 2;
+            return generateRetailBridgeOrderProof({
+              depositSourceAsset: context.sourceAsset,
+              depositNote: context.orderNote,
+              swapInNote: context.swapInNote,
+              feeRatio: context.orderNote.feeRatio,
+              feeAmount: context.feeAmount,
+              destChain: context.destChainId,
+              bridgeFeeAmount: context.bridgeFeeAmount,
+              address: context.address,
+              signedMessage: context.signature
+            });
+          case 2:
+            proof = _context4.v;
+            return _context4.a(2, proof);
+        }
+      }, _callee4);
+    }));
+    function generateProof(_x13) {
+      return _generateProof.apply(this, arguments);
+    }
+    return generateProof;
+  }();
+  _proto.computeDepositId = /*#__PURE__*/function () {
+    var _computeDepositId = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(context) {
+      var callDataHash, currentNonce, packedData, depositCommitment;
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            if (!(!context || !context.callData || !context.orderNote || !context.swapInNote || !context.address || context.feeAmount === undefined || !context.signature || !context.sourceChainId || !context.destChainId || !context.sourceAsset || context.bridgeFeeAmount === undefined)) {
+              _context5.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            callDataHash = ethers.ethers.solidityPackedKeccak256(['address', 'bytes'], [this._darkSwapOfSourceChain.contracts.synaraDarkSwapOnBridgeAssetManager, context.callData]);
+            context.callDataHash = callDataHash;
+            _context5.n = 2;
+            return this.getCurrentNonce(context);
+          case 2:
+            currentNonce = _context5.v;
+            context.nonce = currentNonce;
+            packedData = ethers.solidityPacked(["bytes", "address", "bytes32", "address", "address", "bytes32", "bytes32", "bytes32", "bytes32", "bytes32" // _computeCallDataHash(call)
+            ], [_DOMAIN_PREFIX, this._darkSwapOfSourceChain.contracts.synaraBridge, context.canonicalId, this._darkSwapOfSourceChain.contracts.synaraDarkSwapOnBridgeAssetManager, context.address, hexlify32(context.orderNote.amount), hexlify32(context.destChainId), hexlify32(context.nonce), hexlify32(context.sourceChainId), context.callDataHash]);
+            depositCommitment = ethers.keccak256(packedData);
+            return _context5.a(2, depositCommitment);
+        }
+      }, _callee5, this);
+    }));
+    function computeDepositId(_x14) {
+      return _computeDepositId.apply(this, arguments);
+    }
+    return computeDepositId;
+  }();
+  _proto.getCurrentNonce = /*#__PURE__*/function () {
+    var _getCurrentNonce = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(context) {
+      var provider, contract;
+      return _regenerator().w(function (_context6) {
+        while (1) switch (_context6.n) {
+          case 0:
+            provider = this._darkSwapOfSourceChain.provider;
+            contract = new ethers.ethers.Contract(this._darkSwapOfSourceChain.contracts.synaraDarkSwapOnBridgeAssetManager, SynaraDarkSwapOnBridgeAssetManagerAbi.abi, provider);
+            _context6.n = 1;
+            return contract.currentNonce({
+              from: context.address
+            });
+          case 1:
+            return _context6.a(2, _context6.v);
+        }
+      }, _callee6, this);
+    }));
+    function getCurrentNonce(_x15) {
+      return _getCurrentNonce.apply(this, arguments);
+    }
+    return getCurrentNonce;
+  }();
+  _proto.composeCallData = /*#__PURE__*/function () {
+    var _composeCallData = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(context) {
+      var functionSignature, args, iface, fullData;
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.n) {
+          case 0:
+            if (!(!context || !context.orderNote || !context.swapInNote || !context.address || !context.destChainId || !context.sourceAsset || context.bridgeFeeAmount === undefined || !context.proof || !context.attestationDetails)) {
+              _context7.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            functionSignature = "_retailBridgeCreateOrder((uint256,uint256,address,bytes32,bytes32,address,address,uint256,uint256,bytes32,bytes32,address),(uint256,bytes32[],uint256,uint256))";
+            args = {
+              destChain: BigInt(context.destChainId),
+              bridgeFee: context.bridgeFeeAmount,
+              owner: context.address,
+              depositOutNote: hexlify32(context.orderNote.note),
+              depositOutNoteFooter: context.proof.depositFooter,
+              outAssetSource: context.sourceAsset,
+              outAssetDest: context.orderNote.address,
+              outAmount: context.orderNote.amount,
+              feeRatio: context.orderNote.feeRatio,
+              inNote: hexlify32(context.swapInNote.note),
+              inNoteFooter: context.proof.swapInNoteFooter,
+              destContractAddress: this._darkSwapOfDestChain.contracts.synaraDarkSwapOnBridgeAssetManager
+            };
+            iface = new ethers.ethers.Interface(["function " + functionSignature]);
+            fullData = iface.encodeFunctionData('_retailBridgeCreateOrder', [[args.destChain, args.bridgeFee, args.owner, args.depositOutNote, args.depositOutNoteFooter, args.outAssetSource, args.outAssetDest, args.outAmount, args.feeRatio, args.inNote, args.inNoteFooter, args.destContractAddress], [context.attestationDetails.attestationId, context.attestationDetails.merklePath, context.attestationDetails.leafCount, context.attestationDetails.index]]);
+            return _context7.a(2, fullData);
+        }
+      }, _callee7, this);
+    }));
+    function composeCallData(_x16) {
+      return _composeCallData.apply(this, arguments);
+    }
+    return composeCallData;
+  }();
+  _proto.allowance = /*#__PURE__*/function () {
+    var _allowance = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(context) {
+      var signer, asset, amount, allowanceContract, allowance, isLegacy, contract, tx;
+      return _regenerator().w(function (_context8) {
+        while (1) switch (_context8.n) {
+          case 0:
+            if (!(!context || !context.orderNote || !context.address || !context.signature || !context.proof)) {
+              _context8.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            signer = this._darkSwapOfSourceChain.signer;
+            asset = context.orderNote.asset;
+            amount = context.orderNote.amount;
+            allowanceContract = new ethers.ethers.Contract(asset, ERC20Abi.abi, this._darkSwapOfSourceChain);
+            _context8.n = 2;
+            return allowanceContract.allowance(signer.getAddress(), this._darkSwapOfSourceChain.contracts.darkSwapAssetManager);
+          case 2:
+            allowance = _context8.v;
+            if (!(BigInt(allowance) < amount)) {
+              _context8.n = 4;
+              break;
+            }
+            isLegacy = legacyTokenConfig.hasOwnProperty(this._darkSwapOfSourceChain.chainId) && legacyTokenConfig[this._darkSwapOfSourceChain.chainId].includes(asset.toLowerCase());
+            contract = new ethers.ethers.Contract(asset, isLegacy ? ERC20_USDT.abi : ERC20Abi.abi, signer);
+            _context8.n = 3;
+            return contract.approve(this._darkSwapOfSourceChain.contracts.darkSwapAssetManager, hexlify32(MAX_ALLOWANCE));
+          case 3:
+            tx = _context8.v;
+            _context8.n = 4;
+            return tx.wait();
+          case 4:
+            return _context8.a(2);
+        }
+      }, _callee8, this);
     }));
-    function allowance(_x12) {
+    function allowance(_x17) {
       return _allowance.apply(this, arguments);
     }
     return allowance;
   }();
   _proto.execute = /*#__PURE__*/function () {
-    var _execute = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(context) {
-      var depositId, txHash;
-      return _regenerator().w(function (_context4) {
-        while (1) switch (_context4.n) {
+    var _execute2 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(context) {
+      var callData, txHash;
+      return _regenerator().w(function (_context9) {
+        while (1) switch (_context9.n) {
           case 0:
-            _context4.n = 1;
-            return this.computeDepositId(context);
+            _context9.n = 1;
+            return this.submitProof(context);
           case 1:
-            depositId = _context4.v;
-            context.depositId = depositId;
-            txHash = "0x0";
-            return _context4.a(2, {
-              depositId: depositId,
+            _context9.n = 2;
+            return this.composeCallData(context);
+          case 2:
+            callData = _context9.v;
+            context.callData = callData;
+            _context9.n = 3;
+            return this.computeDepositId(context);
+          case 3:
+            context.depositId = _context9.v;
+            _context9.n = 4;
+            return this._execute(context);
+          case 4:
+            txHash = _context9.v;
+            return _context9.a(2, {
+              depositId: context.depositId,
               txHash: txHash
             });
         }
-      }, _callee4, this);
+      }, _callee9, this);
     }));
-    function execute(_x13) {
-      return _execute.apply(this, arguments);
+    function execute(_x18) {
+      return _execute2.apply(this, arguments);
     }
     return execute;
   }();
+  _proto._execute = /*#__PURE__*/function () {
+    var _execute3 = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(context) {
+      var contract, ethAmount, tx;
+      return _regenerator().w(function (_context0) {
+        while (1) switch (_context0.n) {
+          case 0:
+            if (!(!context || !context.destChainId || !context.attestationDetails || !context.orderNote || !context.swapInNote || !context.sourceAsset || !context.sourceAmount || context.bridgeFeeAmount === undefined || !context.depositId || !context.proof)) {
+              _context0.n = 1;
+              break;
+            }
+            throw new DarkSwapError('Invalid context');
+          case 1:
+            contract = new ethers.ethers.Contract(this._darkSwapOfSourceChain.contracts.synaraDarkSwapOnBridgeAssetManager, SynaraDarkSwapOnBridgeAssetManagerAbi.abi, this._darkSwapOfSourceChain.signer);
+            ethAmount = 0n;
+            if (!isNativeAsset(context.sourceAsset)) {
+              _context0.n = 2;
+              break;
+            }
+            ethAmount = context.sourceAmount;
+            _context0.n = 3;
+            break;
+          case 2:
+            _context0.n = 3;
+            return this.allowance(context);
+          case 3:
+            _context0.n = 4;
+            return contract.retailDepositBridge(context.depositId, [hexlify32(BigInt(context.destChainId)), hexlify32(context.bridgeFeeAmount), context.address, hexlify32(context.orderNote.note), context.proof.depositFooter, context.sourceAsset, context.orderNote.address, hexlify32(context.sourceAmount), hexlify32(context.orderNote.feeRatio), hexlify32(context.swapInNote.note), context.proof.swapInNoteFooter, this._darkSwapOfDestChain.contracts.synaraDarkSwapOnBridgeAssetManager], [hexlify32(context.attestationDetails.attestationId), context.attestationDetails.merklePath, hexlify32(context.attestationDetails.leafCount), hexlify32(context.attestationDetails.index)], {
+              value: bn_to_0xhex(ethAmount)
+            });
+          case 4:
+            tx = _context0.v;
+            _context0.n = 5;
+            return tx.wait();
+          case 5:
+            return _context0.a(2, tx.hash);
+        }
+      }, _callee0, this);
+    }));
+    function _execute(_x19) {
+      return _execute3.apply(this, arguments);
+    }
+    return _execute;
+  }();
   return BridgeCreateOrderService;
 }();