@thesingularitynetwork/singularity-sdk-lite 0.0.0-stage → 0.2.0

package/dist/singularity-sdk-lite.esm.js

@@ -0,0 +1,3836 @@
+import { createNote, generateDepositProof, generateWithdrawProof, calcNullifier, getNullifier, validateNote } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+import { ethers } from 'ethers';
+import axios from 'axios';
+
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+      args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
+  }
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+
+var _format = "hh-sol-artifact-1";
+var contractName = "DarkpoolAssetManager";
+var sourceName = "contracts/core/DarkpoolAssetManager.sol";
+var abi = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolERC20",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "assetPoolERC721",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "assetPoolETH",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "verifierHub",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "relayerHub",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "feeManager",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "comlianceManager",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "merkleTreeOperator",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "mimc254",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "initialOwner",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "target",
+				type: "address"
+			}
+		],
+		name: "AddressEmptyCode",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "AddressInsufficientBalance",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "FailedInnerCall",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "MerkleRootNotAllowed",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteAlreadyCreated",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteFooterUsed",
+		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: [
+		],
+		name: "RelayerNotRegistered",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "token",
+				type: "address"
+			}
+		],
+		name: "SafeERC20FailedOperation",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "address",
+				name: "depositor",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			}
+		],
+		name: "Deposit",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn1",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn2",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut1",
+				type: "bytes32"
+			}
+		],
+		name: "Join",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn1",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn2",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut1",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut2",
+				type: "bytes32"
+			}
+		],
+		name: "JoinSplit",
+		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"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut1",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut2",
+				type: "bytes32"
+			}
+		],
+		name: "Split",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteOut",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "noteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "nullifierIn",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			}
+		],
+		name: "Withdraw",
+		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: [
+			{
+				internalType: "address",
+				name: "_asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "_amount",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteCommitment",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "depositERC20",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_noteCommitment",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "depositETH",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getAssetPoolERC20",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getAssetPoolERC721",
+		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: "getComplianceManager",
+		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: "getRelayerHub",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getVerifierHub",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "join",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "joinSplit",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		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: "address",
+				name: "assetPoolERC20",
+				type: "address"
+			}
+		],
+		name: "setAssetPoolERC20",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolERC721",
+				type: "address"
+			}
+		],
+		name: "setAssetPoolERC721",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetPoolETH",
+				type: "address"
+			}
+		],
+		name: "setAssetPoolETH",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "complianceManager",
+				type: "address"
+			}
+		],
+		name: "setComplianceManager",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "feeManager",
+				type: "address"
+			}
+		],
+		name: "setFeeManager",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "relayerHub",
+				type: "address"
+			}
+		],
+		name: "setRelayerHub",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "verifierHub",
+				type: "address"
+			}
+		],
+		name: "setVerifierHub",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter1",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter2",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "split",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifierIn",
+				type: "bytes32"
+			},
+			{
+				internalType: "address",
+				name: "_asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "_amount",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteOut",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_noteFooter",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			}
+		],
+		name: "transfer",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_asset",
+				type: "address"
+			},
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			},
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifier",
+				type: "bytes32"
+			},
+			{
+				internalType: "address",
+				name: "_recipient",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "_relayer",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "_amount",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_relayerGasFee",
+				type: "uint256"
+			}
+		],
+		name: "withdrawERC20",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes",
+				name: "_proof",
+				type: "bytes"
+			},
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "_nullifier",
+				type: "bytes32"
+			},
+			{
+				internalType: "address payable",
+				name: "_recipient",
+				type: "address"
+			},
+			{
+				internalType: "address payable",
+				name: "_relayer",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "_relayerGasFee",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_amount",
+				type: "uint256"
+			}
+		],
+		name: "withdrawETH",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		stateMutability: "payable",
+		type: "receive"
+	}
+];
+var bytecode = "";
+var deployedBytecode = "";
+var linkReferences = {
+};
+var deployedLinkReferences = {
+};
+var DarkpoolAssetManagerAbi = {
+	_format: _format,
+	contractName: contractName,
+	sourceName: sourceName,
+	abi: abi,
+	bytecode: bytecode,
+	deployedBytecode: deployedBytecode,
+	linkReferences: linkReferences,
+	deployedLinkReferences: deployedLinkReferences
+};
+
+var _format$1 = "hh-sol-artifact-1";
+var contractName$1 = "IERC20";
+var sourceName$1 = "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+var abi$1 = [
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+var bytecode$1 = "0x";
+var deployedBytecode$1 = "0x";
+var linkReferences$1 = {
+};
+var deployedLinkReferences$1 = {
+};
+var ERC20Abi = {
+	_format: _format$1,
+	contractName: contractName$1,
+	sourceName: sourceName$1,
+	abi: abi$1,
+	bytecode: bytecode$1,
+	deployedBytecode: deployedBytecode$1,
+	linkReferences: linkReferences$1,
+	deployedLinkReferences: deployedLinkReferences$1
+};
+
+var _format$2 = "hh-sol-artifact-1";
+var contractName$2 = "IERC20";
+var sourceName$2 = "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+var abi$2 = [
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+var bytecode$2 = "0x";
+var deployedBytecode$2 = "0x";
+var linkReferences$2 = {
+};
+var deployedLinkReferences$2 = {
+};
+var ERC20_USDT = {
+	_format: _format$2,
+	contractName: contractName$2,
+	sourceName: sourceName$2,
+	abi: abi$2,
+	bytecode: bytecode$2,
+	deployedBytecode: deployedBytecode$2,
+	linkReferences: linkReferences$2,
+	deployedLinkReferences: deployedLinkReferences$2
+};
+
+var DarkpoolError = /*#__PURE__*/function (_Error) {
+  function DarkpoolError(message) {
+    var _this;
+    _this = _Error.call(this, message) || this;
+    _this.name = 'DarkpoolError';
+    return _this;
+  }
+  _inheritsLoose(DarkpoolError, _Error);
+  return DarkpoolError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var NoteOnChainStatus;
+(function (NoteOnChainStatus) {
+  NoteOnChainStatus["ACTIVE"] = "ACTIVE";
+  NoteOnChainStatus["SPENT"] = "SPENT";
+  NoteOnChainStatus["LOCKED"] = "LOCKED";
+  NoteOnChainStatus["UNKNOWN"] = "UNKNOWN";
+})(NoteOnChainStatus || (NoteOnChainStatus = {}));
+
+var NATIVE_ASSETS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+function isNativeAsset(asset) {
+  return asset.toLowerCase() === NATIVE_ASSETS.toLowerCase();
+}
+function isAddressEquals(address1, address2) {
+  if (!address1 || !address2) return false;
+  return address1.toLowerCase() === address2.toLowerCase();
+}
+function hexlify32(value) {
+  return ethers.zeroPadValue(ethers.toBeHex(value), 32);
+}
+function hexlify16(value) {
+  return ethers.zeroPadValue(ethers.toBeHex(value), 16);
+}
+function hexlify8(value) {
+  return ethers.zeroPadValue(ethers.toBeHex(value), 8);
+}
+function hexlify5(value) {
+  return ethers.zeroPadValue(ethers.toBeHex(value), 5);
+}
+function hexlify3(value) {
+  return ethers.zeroPadValue(ethers.toBeHex(value), 3);
+}
+function hexlify1(value) {
+  return ethers.toBeHex(value);
+}
+function isHexEquals(hex1, hex2) {
+  if (!hex1 || !hex2) return false;
+  return hex1.toLowerCase() === hex2.toLowerCase();
+}
+
+var BaseContext = /*#__PURE__*/function () {
+  function BaseContext(signature) {
+    this._signature = signature;
+  }
+  return _createClass(BaseContext, [{
+    key: "signature",
+    get: function get() {
+      return this._signature;
+    }
+  }, {
+    key: "merkleRoot",
+    get: function get() {
+      return this._merkleRoot;
+    },
+    set: function set(merkleRoot) {
+      this._merkleRoot = merkleRoot;
+    }
+  }, {
+    key: "tx",
+    get: function get() {
+      return this._tx;
+    },
+    set: function set(tx) {
+      this._tx = tx;
+    }
+  }]);
+}();
+var BaseRelayerContext = /*#__PURE__*/function (_BaseContext) {
+  function BaseRelayerContext(relayer, signature) {
+    var _this;
+    _this = _BaseContext.call(this, signature) || this;
+    _this._relayer = relayer;
+    return _this;
+  }
+  _inheritsLoose(BaseRelayerContext, _BaseContext);
+  return _createClass(BaseRelayerContext, [{
+    key: "relayer",
+    get: function get() {
+      return this._relayer;
+    }
+  }, {
+    key: "jobId",
+    get: function get() {
+      return this._jobId;
+    },
+    set: function set(jobId) {
+      this._jobId = jobId;
+    }
+  }]);
+}(BaseContext);
+var BaseContractService = function BaseContractService(_darkPool) {
+  this._darkPool = _darkPool;
+};
+var BaseRelayerService = /*#__PURE__*/function () {
+  function BaseRelayerService(_darkPool) {
+    this._darkPool = _darkPool;
+  }
+  var _proto = BaseRelayerService.prototype;
+  _proto.execute = /*#__PURE__*/function () {
+    var _execute = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context) {
+      var relayerRequest, response;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return this.getRelayerRequest(context);
+          case 2:
+            relayerRequest = _context.sent;
+            _context.next = 5;
+            return axios.post(context.relayer.hostUrl + this.getRelayerPath(), relayerRequest);
+          case 5:
+            response = _context.sent;
+            if (!(response.status == 200)) {
+              _context.next = 11;
+              break;
+            }
+            context.jobId = response.data.id;
+            return _context.abrupt("return", response.data.id);
+          case 11:
+            if (!(response.status == 400)) {
+              _context.next = 15;
+              break;
+            }
+            throw new Error('Request error' + response.data.error);
+          case 15:
+            throw new Error('Relayer not asscessable');
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function execute(_x) {
+      return _execute.apply(this, arguments);
+    }
+    return execute;
+  }();
+  _proto.executeAndWaitForResult = /*#__PURE__*/function () {
+    var _executeAndWaitForResult = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+      var _yield$this$pollJobSt, error, txHash;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return this.execute(context);
+          case 2:
+            _context2.next = 4;
+            return this.pollJobStatus(context);
+          case 4:
+            _yield$this$pollJobSt = _context2.sent;
+            error = _yield$this$pollJobSt.error;
+            txHash = _yield$this$pollJobSt.txHash;
+            console.log('relayer response, error and tx: ', error, txHash);
+            if (!error) {
+              _context2.next = 10;
+              break;
+            }
+            throw new DarkpoolError(error);
+          case 10:
+            _context2.next = 12;
+            return this.postExecute(context);
+          case 12:
+            return _context2.abrupt("return", _context2.sent);
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function executeAndWaitForResult(_x2) {
+      return _executeAndWaitForResult.apply(this, arguments);
+    }
+    return executeAndWaitForResult;
+  }();
+  _proto.pollJobStatus = /*#__PURE__*/function () {
+    var _pollJobStatus = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(context) {
+      var tries, txHash, response, error, _response$data, _txHash, status, failedReason;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            tries = 1;
+            txHash = undefined;
+          case 2:
+            if (!(tries <= 100)) {
+              _context3.next = 30;
+              break;
+            }
+            if (!(tries >= 100)) {
+              _context3.next = 5;
+              break;
+            }
+            return _context3.abrupt("break", 30);
+          case 5:
+            _context3.prev = 5;
+            _context3.next = 8;
+            return axios.get(context.relayer.hostUrl + "/v1/jobs/" + context.jobId);
+          case 8:
+            response = _context3.sent;
+            if (!(response.status === 400)) {
+              _context3.next = 13;
+              break;
+            }
+            error = response.data.error;
+            console.log(error);
+            return _context3.abrupt("return", {
+              error: 'Failed to submit transaction to relayer:' + error,
+              txHash: undefined
+            });
+          case 13:
+            if (!(response.status === 200)) {
+              _context3.next = 20;
+              break;
+            }
+            _response$data = response.data, _txHash = _response$data.txHash, status = _response$data.status, failedReason = _response$data.failedReason;
+            context.tx = _txHash;
+            if (!(status === 'FAILED')) {
+              _context3.next = 18;
+              break;
+            }
+            return _context3.abrupt("return", {
+              error: failedReason != null ? failedReason : 'Transaction failed.',
+              txHash: _txHash
+            });
+          case 18:
+            if (!(status === 'CONFIRMED' || status === 'MINED')) {
+              _context3.next = 20;
+              break;
+            }
+            return _context3.abrupt("return", {
+              error: undefined,
+              txHash: _txHash
+            });
+          case 20:
+            _context3.next = 22;
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, 5000);
+            });
+          case 22:
+            _context3.next = 27;
+            break;
+          case 24:
+            _context3.prev = 24;
+            _context3.t0 = _context3["catch"](5);
+            console.log(_context3.t0);
+          case 27:
+            tries++;
+            _context3.next = 2;
+            break;
+          case 30:
+            return _context3.abrupt("return", {
+              error: 'Waited too long for transaction to be mined.',
+              txHash: txHash
+            });
+          case 31:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[5, 24]]);
+    }));
+    function pollJobStatus(_x3) {
+      return _pollJobStatus.apply(this, arguments);
+    }
+    return pollJobStatus;
+  }();
+  return BaseRelayerService;
+}();
+function transferCodeToNoteFooter(transferCode, chainId) {
+  var params = transferCode.trim().split('-');
+  if (params.length < 3 || params[0] != 'ONEOFF' || params[1] != 'RECIPIENT' || params[2] != chainId.toString()) {
+    throw new DarkpoolError('Invalid receiver code');
+  }
+  return BigInt(params[3]);
+}
+function validateRecipientCode(code) {
+  var codePattern = /^(ONEOFF-RECIPIENT)-(\d+)-(\d+)/gm;
+  return codePattern.test(code);
+}
+
+var ChainId;
+(function (ChainId) {
+  ChainId[ChainId["HARDHAT"] = 31337] = "HARDHAT";
+  ChainId[ChainId["HARDHAT_ARBITRUM"] = 31338] = "HARDHAT_ARBITRUM";
+  ChainId[ChainId["HARDHAT_BASE"] = 31339] = "HARDHAT_BASE";
+  ChainId[ChainId["MAINNET"] = 1] = "MAINNET";
+  ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
+  ChainId[ChainId["ARBITRUM_ONE"] = 42161] = "ARBITRUM_ONE";
+  ChainId[ChainId["BASE"] = 8453] = "BASE";
+  ChainId[ChainId["BounceBit"] = 6001] = "BounceBit";
+  ChainId[ChainId["BounceBitTestnet"] = 6000] = "BounceBitTestnet";
+})(ChainId || (ChainId = {}));
+
+var _relayerPathConfig, _legacyTokenConfig;
+var Action;
+(function (Action) {
+  Action["CURVE_LP_DEPOSIT"] = "CURVE_LP_DEPOSIT";
+  Action["CURVE_LP_WITHDRAW"] = "CURVE_LP_WITHDRAW";
+  Action["CURVE_MULTI_SWAP"] = "CURVE_MULTI_SWAP";
+  Action["DEFI_INFRA"] = "DEFI_INFRA";
+  Action["STAKE"] = "STAKE";
+  Action["REDEEM"] = "REDEEM";
+  Action["UNISWAP_SINGLE_SWAP"] = "UNISWAP_SINGLE_SWAP";
+  Action["UNISWAP_LP_DEPOSIT"] = "UNISWAP_LP_DEPOSIT";
+  Action["UNISWAP_LP_WITHDRAW"] = "UNISWAP_LP_WITHDRAW";
+  Action["UNISWAP_LP_COLLECT_FEE"] = "UNISWAP_LP_COLLECT_FEE";
+  Action["WITHDRAW"] = "WITHDRAW";
+  Action["AERODROME_SWAP"] = "AERODROME_SWAP";
+  Action["AERODROME_LP_DEPOSIT"] = "AERODROME_LP_DEPOSIT";
+  Action["AERODROME_LP_WITHDRAW"] = "AERODROME_LP_WITHDRAW";
+  Action["ROCKET_POOL_STAKE"] = "ROCKET_POOL_STAKE";
+  Action["ROCKET_POOL_UNSTAKE"] = "ROCKET_POOL_UNSTAKE";
+  Action["SABLIER_CLAIM_STREAM"] = "SABLIER_CLAIM_STREAM";
+  Action["THE_DEEP_NOTE_DEPOSIT"] = "THE_DEEP_NOTE_DEPOSIT";
+  Action["THE_DEEP_WITHDRAW"] = "THE_DEEP_WITHDRAW";
+})(Action || (Action = {}));
+var relayerPathConfig = (_relayerPathConfig = {}, _relayerPathConfig[Action.WITHDRAW] = '/v1/pgDarkPoolWithdraw', _relayerPathConfig[Action.UNISWAP_SINGLE_SWAP] = '/v1/pgDarkPoolUniswapSingleSwap', _relayerPathConfig[Action.UNISWAP_LP_DEPOSIT] = '/v1/pgDarkPoolUniswapLP', _relayerPathConfig[Action.UNISWAP_LP_WITHDRAW] = '/v1/pgDarkPoolUniswapRemoveLiquidity', _relayerPathConfig[Action.UNISWAP_LP_COLLECT_FEE] = '/v1/pgDarkPoolUniswapCollectFees', _relayerPathConfig[Action.CURVE_LP_DEPOSIT] = '/v1/pgDarkPoolCurveAddLiquidity', _relayerPathConfig[Action.CURVE_LP_WITHDRAW] = '/v1/pgDarkPoolCurveRemoveLiquidity', _relayerPathConfig[Action.CURVE_MULTI_SWAP] = '/v1/pgDarkPoolCurveMultiExchange', _relayerPathConfig[Action.DEFI_INFRA] = '/v1/pgDarkPoolDefiInfra', _relayerPathConfig[Action.STAKE] = '/v1/pgDarkPoolZkStake', _relayerPathConfig[Action.REDEEM] = '/v1/pgDarkPoolZkRedeem', _relayerPathConfig[Action.AERODROME_SWAP] = '/v1/pgDarkPoolAerodromeSwap', _relayerPathConfig[Action.AERODROME_LP_DEPOSIT] = '/v1/pgDarkPoolAerodromeAddLiquidity', _relayerPathConfig[Action.AERODROME_LP_WITHDRAW] = '/v1/pgDarkPoolAerodromeRemoveLiquidity', _relayerPathConfig[Action.ROCKET_POOL_STAKE] = '/v1/pgDarkPoolRocketPoolStake', _relayerPathConfig[Action.ROCKET_POOL_UNSTAKE] = '/v1/pgDarkPoolRocketPoolUnStake', _relayerPathConfig[Action.SABLIER_CLAIM_STREAM] = '/v1/pgDarkPoolSablierClaim', _relayerPathConfig[Action.THE_DEEP_NOTE_DEPOSIT] = '/v1/pgDarkPoolTheDeepNoteDeposit', _relayerPathConfig[Action.THE_DEEP_WITHDRAW] = '/v1/pgDarkPoolTheDeepWithdraw', _relayerPathConfig);
+var legacyTokenConfig = (_legacyTokenConfig = {}, _legacyTokenConfig[ChainId.MAINNET] = ['0xdac17f958d2ee523a2206206994597c13d831ec7'], _legacyTokenConfig[ChainId.HARDHAT] = ['0xdac17f958d2ee523a2206206994597c13d831ec7'], _legacyTokenConfig);
+
+var MAX_ALLOWANCE = /*#__PURE__*/BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935'); // 2**256 - 1
+var DepositContext = /*#__PURE__*/function (_BaseContext) {
+  function DepositContext(signature) {
+    return _BaseContext.call(this, signature) || this;
+  }
+  _inheritsLoose(DepositContext, _BaseContext);
+  return _createClass(DepositContext, [{
+    key: "note",
+    get: function get() {
+      return this._note;
+    },
+    set: function set(note) {
+      this._note = note;
+    }
+  }, {
+    key: "address",
+    get: function get() {
+      return this._address;
+    },
+    set: function set(address) {
+      this._address = address;
+    }
+  }, {
+    key: "proof",
+    get: function get() {
+      return this._proof;
+    },
+    set: function set(proof) {
+      this._proof = proof;
+    }
+  }]);
+}(BaseContext);
+var DepositService = /*#__PURE__*/function (_BaseContractService) {
+  function DepositService(_darkPool) {
+    return _BaseContractService.call(this, _darkPool) || this;
+  }
+  _inheritsLoose(DepositService, _BaseContractService);
+  var _proto = DepositService.prototype;
+  _proto.prepare = /*#__PURE__*/function () {
+    var _prepare = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(asset, amount, walletAddress, signature) {
+      var note, context;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return createNote(asset, amount, signature);
+          case 2:
+            note = _context.sent;
+            context = new DepositContext(signature);
+            context.note = note;
+            context.address = walletAddress;
+            return _context.abrupt("return", {
+              context: context,
+              outNotes: [note]
+            });
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function prepare(_x, _x2, _x3, _x4) {
+      return _prepare.apply(this, arguments);
+    }
+    return prepare;
+  }();
+  _proto.generateProof = /*#__PURE__*/function () {
+    var _generateProof = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+      var proof;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(!context || !context.note || !context.address || !context.signature)) {
+              _context2.next = 2;
+              break;
+            }
+            throw new DarkpoolError('Invalid context');
+          case 2:
+            _context2.next = 4;
+            return generateDepositProof({
+              note: context.note,
+              signedMessage: context.signature,
+              address: context.address,
+              options: this._darkPool.proofOptions
+            });
+          case 4:
+            proof = _context2.sent;
+            context.proof = proof;
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function generateProof(_x5) {
+      return _generateProof.apply(this, arguments);
+    }
+    return generateProof;
+  }();
+  _proto.execute = /*#__PURE__*/function () {
+    var _execute = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(context) {
+      var signer, contract, tx, _tx;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(!context || !context.note || !context.address || !context.signature || !context.proof)) {
+              _context3.next = 2;
+              break;
+            }
+            throw new DarkpoolError('Invalid context');
+          case 2:
+            signer = this._darkPool.signer;
+            contract = new ethers.Contract(this._darkPool.contracts.darkpoolAssetManager, DarkpoolAssetManagerAbi.abi, signer);
+            if (isNativeAsset(context.note.asset)) {
+              _context3.next = 13;
+              break;
+            }
+            _context3.next = 7;
+            return this.allowance(context);
+          case 7:
+            _context3.next = 9;
+            return contract.depositERC20(context.note.asset, hexlify32(context.note.amount), hexlify32(context.note.note), context.proof.noteFooter, context.proof.proof.proof);
+          case 9:
+            tx = _context3.sent;
+            return _context3.abrupt("return", tx.hash);
+          case 13:
+            _context3.next = 15;
+            return contract.depositETH(hexlify32(context.note.note), context.proof.noteFooter, context.proof.proof.proof, {
+              value: context.note.amount
+            });
+          case 15:
+            _tx = _context3.sent;
+            return _context3.abrupt("return", _tx.hash);
+          case 17:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function execute(_x6) {
+      return _execute.apply(this, arguments);
+    }
+    return execute;
+  }();
+  _proto.allowance = /*#__PURE__*/function () {
+    var _allowance = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context) {
+      var signer, allowanceContract, allowance, isLegacy, contract, tx;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(!context || !context.note || !context.address || !context.signature || !context.proof)) {
+              _context4.next = 2;
+              break;
+            }
+            throw new DarkpoolError('Invalid context');
+          case 2:
+            signer = this._darkPool.signer;
+            allowanceContract = new ethers.Contract(context.note.asset, ERC20Abi.abi, this._darkPool);
+            _context4.next = 6;
+            return allowanceContract.allowance(signer.getAddress(), this._darkPool.contracts.darkpoolAssetManager);
+          case 6:
+            allowance = _context4.sent;
+            if (!(BigInt(allowance) < context.note.amount)) {
+              _context4.next = 15;
+              break;
+            }
+            isLegacy = legacyTokenConfig.hasOwnProperty(this._darkPool.chainId) && legacyTokenConfig[this._darkPool.chainId].includes(context.note.asset.toLowerCase());
+            contract = new ethers.Contract(context.note.asset, isLegacy ? ERC20_USDT.abi : ERC20Abi.abi, signer);
+            _context4.next = 12;
+            return contract.approve(this._darkPool.contracts.darkpoolAssetManager, hexlify32(MAX_ALLOWANCE));
+          case 12:
+            tx = _context4.sent;
+            _context4.next = 15;
+            return tx.wait();
+          case 15:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function allowance(_x7) {
+      return _allowance.apply(this, arguments);
+    }
+    return allowance;
+  }();
+  _proto.getContractCallParameters = function getContractCallParameters(context) {
+    if (!context || !context.note || !context.address || !context.signature || !context.proof) {
+      throw new DarkpoolError('Invalid context');
+    }
+    return {
+      proof: context.proof.proof.proof,
+      asset: context.note.asset,
+      amount: hexlify32(context.note.amount),
+      note: hexlify32(context.note.note),
+      noteFooter: context.proof.noteFooter
+    };
+  };
+  return DepositService;
+}(BaseContractService);
+
+var _format$3 = "hh-sol-artifact-1";
+var contractName$3 = "MerkleTreeOperator";
+var sourceName$3 = "contracts/core/MerkleTreeOperator.sol";
+var abi$3 = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "initialOwner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "mimc254Address",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		inputs: [
+		],
+		name: "InvalidLeaf",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "MerkleRootNotAllowed",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteAlreadyCreated",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "NoteFooterUsed",
+		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"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "previousOwner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "OwnershipTransferred",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "leaf",
+				type: "bytes32"
+			}
+		],
+		name: "appendMerkleLeaf",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetManager",
+				type: "address"
+			}
+		],
+		name: "assetManagersRegistered",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "registered",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_noteCommitment",
+				type: "bytes32"
+			}
+		],
+		name: "getMerklePath",
+		outputs: [
+			{
+				internalType: "bytes32[]",
+				name: "",
+				type: "bytes32[]"
+			},
+			{
+				internalType: "bool[]",
+				name: "",
+				type: "bool[]"
+			},
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getMerkleRoot",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getmerkleNodes",
+		outputs: [
+			{
+				internalType: "bytes32[][]",
+				name: "",
+				type: "bytes32[][]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		name: "merkleNodes",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "merkleRoot",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_merkleRoot",
+				type: "bytes32"
+			}
+		],
+		name: "merkleRootIsAllowed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "root",
+				type: "bytes32"
+			}
+		],
+		name: "merkleRootsAllowed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "allowed",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "mimcBn254Address",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "commitment",
+				type: "bytes32"
+			}
+		],
+		name: "noteCommitmentsCreated",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "created",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_noteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "noteFooterIsNotUsed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "noteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "noteFootersUsed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "used",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_noteCommitment",
+				type: "bytes32"
+			}
+		],
+		name: "noteIsNotCreated",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_nullifier",
+				type: "bytes32"
+			}
+		],
+		name: "nullifierIsNotLocked",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "_nullifier",
+				type: "bytes32"
+			}
+		],
+		name: "nullifierIsNotUsed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "nullifier",
+				type: "bytes32"
+			}
+		],
+		name: "nullifiersLocked",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "locked",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "nullifier",
+				type: "bytes32"
+			}
+		],
+		name: "nullifiersUsed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "used",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "owner",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "renounceOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "assetManager",
+				type: "address"
+			},
+			{
+				internalType: "bool",
+				name: "registered",
+				type: "bool"
+			}
+		],
+		name: "setAssetManager",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "commitment",
+				type: "bytes32"
+			}
+		],
+		name: "setNoteCommitmentCreated",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "noteFooter",
+				type: "bytes32"
+			}
+		],
+		name: "setNoteFooterUsed",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "nullifier",
+				type: "bytes32"
+			},
+			{
+				internalType: "bool",
+				name: "locked",
+				type: "bool"
+			}
+		],
+		name: "setNullifierLocked",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "nullifier",
+				type: "bytes32"
+			}
+		],
+		name: "setNullifierUsed",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "newOwner",
+				type: "address"
+			}
+		],
+		name: "transferOwnership",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+var bytecode$3 = "";
+var deployedBytecode$3 = "";
+var linkReferences$3 = {
+};
+var deployedLinkReferences$3 = {
+};
+var MerkleAbi = {
+	_format: _format$3,
+	contractName: contractName$3,
+	sourceName: sourceName$3,
+	abi: abi$3,
+	bytecode: bytecode$3,
+	deployedBytecode: deployedBytecode$3,
+	linkReferences: linkReferences$3,
+	deployedLinkReferences: deployedLinkReferences$3
+};
+
+function getContract(address, darkPool) {
+  var provider = darkPool.provider;
+  return new ethers.Contract(address, MerkleAbi.abi, provider);
+}
+function getMerklePathAndRoot(_x, _x2) {
+  return _getMerklePathAndRoot.apply(this, arguments);
+}
+function _getMerklePathAndRoot() {
+  _getMerklePathAndRoot = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(note, darkPool) {
+    var contract, _yield$contract$getMe, path, index, root;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          contract = getContract(darkPool.contracts.merkleTreeOperator, darkPool);
+          _context.next = 3;
+          return contract.getMerklePath(hexlify32(note));
+        case 3:
+          _yield$contract$getMe = _context.sent;
+          path = _yield$contract$getMe[0];
+          index = _yield$contract$getMe[1];
+          root = _yield$contract$getMe[2];
+          return _context.abrupt("return", {
+            path: path,
+            index: index.map(function (x) {
+              return x ? 1 : 0;
+            }),
+            root: root
+          });
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getMerklePathAndRoot.apply(this, arguments);
+}
+function multiGetMerklePathAndRoot(_x3, _x4) {
+  return _multiGetMerklePathAndRoot.apply(this, arguments);
+}
+function _multiGetMerklePathAndRoot() {
+  _multiGetMerklePathAndRoot = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(notes, darkPool) {
+    var contract, blockNumber, _yield$Promise$all, root, results;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          contract = getContract(darkPool.contracts.merkleTreeOperator, darkPool);
+          _context2.next = 3;
+          return darkPool.provider.getBlockNumber();
+        case 3:
+          blockNumber = _context2.sent;
+          _context2.next = 6;
+          return Promise.all([contract.getMerkleRoot({
+            blockTag: blockNumber
+          })].concat(notes.map(function (note) {
+            return contract.getMerklePath(hexlify32(note), {
+              blockTag: blockNumber
+            });
+          })));
+        case 6:
+          _yield$Promise$all = _context2.sent;
+          root = _yield$Promise$all[0];
+          results = _yield$Promise$all.slice(1);
+          return _context2.abrupt("return", results.map(function (_ref, i) {
+            var path = _ref[0],
+              index = _ref[1];
+            return {
+              noteCommitment: notes[i],
+              path: path,
+              index: index.map(function (x) {
+                return x ? 1 : 0;
+              }),
+              root: root
+            };
+          }));
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _multiGetMerklePathAndRoot.apply(this, arguments);
+}
+
+var WithdrawContext = /*#__PURE__*/function (_BaseRelayerContext) {
+  function WithdrawContext(relayer, signature) {
+    return _BaseRelayerContext.call(this, relayer, signature) || this;
+  }
+  _inheritsLoose(WithdrawContext, _BaseRelayerContext);
+  return _createClass(WithdrawContext, [{
+    key: "note",
+    get: function get() {
+      return this._note;
+    },
+    set: function set(note) {
+      this._note = note;
+    }
+  }, {
+    key: "recipient",
+    get: function get() {
+      return this._recipient;
+    },
+    set: function set(recipient) {
+      this._recipient = recipient;
+    }
+  }, {
+    key: "proof",
+    get: function get() {
+      return this._proof;
+    },
+    set: function set(proof) {
+      this._proof = proof;
+    }
+  }]);
+}(BaseRelayerContext);
+var WithdrawService = /*#__PURE__*/function (_BaseRelayerService) {
+  function WithdrawService(_darkPool) {
+    return _BaseRelayerService.call(this, _darkPool) || this;
+  }
+  _inheritsLoose(WithdrawService, _BaseRelayerService);
+  var _proto = WithdrawService.prototype;
+  _proto.prepare = /*#__PURE__*/function () {
+    var _prepare = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(note, recipient, signature) {
+      var context;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            context = new WithdrawContext(this._darkPool.getRelayer(), signature);
+            context.note = note;
+            context.recipient = recipient;
+            return _context.abrupt("return", {
+              context: context,
+              outPartialNotes: []
+            });
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function prepare(_x, _x2, _x3) {
+      return _prepare.apply(this, arguments);
+    }
+    return prepare;
+  }();
+  _proto.generateProof = /*#__PURE__*/function () {
+    var _generateProof = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+      var path, proof;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(!context || !context.note || !context.recipient || !context.signature)) {
+              _context2.next = 2;
+              break;
+            }
+            throw new DarkpoolError('Invalid context');
+          case 2:
+            _context2.next = 4;
+            return getMerklePathAndRoot(context.note.note, this._darkPool);
+          case 4:
+            path = _context2.sent;
+            context.merkleRoot = path.root;
+            _context2.next = 8;
+            return generateWithdrawProof({
+              note: context.note,
+              address: context.recipient,
+              merkleRoot: path.root,
+              merklePath: path.path,
+              merkleIndex: path.index,
+              relayer: context.relayer.relayerAddress,
+              signedMessage: context.signature,
+              options: this._darkPool.proofOptions
+            });
+          case 8:
+            proof = _context2.sent;
+            context.proof = proof;
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function generateProof(_x4) {
+      return _generateProof.apply(this, arguments);
+    }
+    return generateProof;
+  }();
+  _proto.getRelayerRequest = /*#__PURE__*/function () {
+    var _getRelayerRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(context) {
+      var withdrawRelayerRequest;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(!context || !context.note || !context.signature || !context.merkleRoot || !context.recipient || !context.proof)) {
+              _context3.next = 2;
+              break;
+            }
+            throw new DarkpoolError('Invalid context');
+          case 2:
+            withdrawRelayerRequest = {
+              proof: context.proof.proof.proof,
+              asset: context.note.asset,
+              merkleRoot: context.merkleRoot,
+              nullifier: context.proof.nullifier,
+              recipient: context.recipient,
+              relayer: context.relayer.relayerAddress,
+              amount: hexlify32(context.note.amount),
+              refund: hexlify32(0n),
+              verifierArgs: context.proof.proof.verifyInputs
+            };
+            return _context3.abrupt("return", withdrawRelayerRequest);
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    function getRelayerRequest(_x5) {
+      return _getRelayerRequest.apply(this, arguments);
+    }
+    return getRelayerRequest;
+  }();
+  _proto.getRelayerPath = function getRelayerPath() {
+    return relayerPathConfig[Action.WITHDRAW];
+  }
+  //eslint-disable-next-line @typescript-eslint/no-unused-vars
+  ;
+  _proto.postExecute =
+  /*#__PURE__*/
+  function () {
+    var _postExecute = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context) {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            console.log(context.tx);
+            return _context4.abrupt("return", {
+              txHash: context.tx
+            });
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }));
+    function postExecute(_x6) {
+      return _postExecute.apply(this, arguments);
+    }
+    return postExecute;
+  }();
+  _proto.getRelayerContractCallParameters = function getRelayerContractCallParameters(context) {
+    if (!context || !context.note || !context.recipient || !context.signature || !context.proof) {
+      throw new DarkpoolError('Invalid context');
+    }
+    return {
+      proof: context.proof.proof.proof,
+      asset: context.note.asset,
+      merkleRoot: context.merkleRoot,
+      nullifier: context.proof.nullifier,
+      recipient: context.recipient,
+      relayer: context.relayer.relayerAddress,
+      amount: hexlify32(context.note.amount)
+    };
+  };
+  return WithdrawService;
+}(BaseRelayerService);
+
+function getContract$1(address, darkPool) {
+  var provider = darkPool.provider;
+  return new ethers.Contract(address, MerkleAbi.abi, provider);
+}
+function getNoteOnChainStatus(_x, _x2, _x3) {
+  return _getNoteOnChainStatus.apply(this, arguments);
+}
+function _getNoteOnChainStatus() {
+  _getNoteOnChainStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(darkPool, note, nullifier) {
+    var contract, isCreated, isSpent, isLocked;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          contract = getContract$1(darkPool.contracts.merkleTreeOperator, darkPool);
+          _context.next = 3;
+          return contract.noteCommitmentsCreated(note);
+        case 3:
+          isCreated = _context.sent;
+          if (isCreated) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return", NoteOnChainStatus.UNKNOWN);
+        case 6:
+          _context.next = 8;
+          return contract.nullifiersUsed(nullifier);
+        case 8:
+          isSpent = _context.sent;
+          if (!isSpent) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("return", NoteOnChainStatus.SPENT);
+        case 11:
+          _context.next = 13;
+          return contract.nullifiersLocked(nullifier);
+        case 13:
+          isLocked = _context.sent;
+          if (!isLocked) {
+            _context.next = 16;
+            break;
+          }
+          return _context.abrupt("return", NoteOnChainStatus.LOCKED);
+        case 16:
+          return _context.abrupt("return", NoteOnChainStatus.ACTIVE);
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getNoteOnChainStatus.apply(this, arguments);
+}
+function getNoteOnChainStatusByPublicKey(_x4, _x5, _x6) {
+  return _getNoteOnChainStatusByPublicKey.apply(this, arguments);
+}
+function _getNoteOnChainStatusByPublicKey() {
+  _getNoteOnChainStatusByPublicKey = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(darkPool, note, publicKey) {
+    var nullifier, onChainStatus;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          nullifier = calcNullifier(note.rho, publicKey);
+          _context2.next = 3;
+          return getNoteOnChainStatus(darkPool, hexlify32(note.note), hexlify32(nullifier));
+        case 3:
+          onChainStatus = _context2.sent;
+          return _context2.abrupt("return", onChainStatus);
+        case 5:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _getNoteOnChainStatusByPublicKey.apply(this, arguments);
+}
+function getNoteOnChainStatusBySignature(_x7, _x8, _x9) {
+  return _getNoteOnChainStatusBySignature.apply(this, arguments);
+}
+function _getNoteOnChainStatusBySignature() {
+  _getNoteOnChainStatusBySignature = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(darkPool, note, signature) {
+    var nullifier, onChainStatus;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return getNullifier({
+            rho: note.rho,
+            signedMessage: signature
+          });
+        case 2:
+          nullifier = _context3.sent;
+          _context3.next = 5;
+          return getNoteOnChainStatus(darkPool, hexlify32(note.note), nullifier);
+        case 5:
+          onChainStatus = _context3.sent;
+          return _context3.abrupt("return", onChainStatus);
+        case 7:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _getNoteOnChainStatusBySignature.apply(this, arguments);
+}
+function isNoteActive(_x10, _x11, _x12) {
+  return _isNoteActive.apply(this, arguments);
+}
+function _isNoteActive() {
+  _isNoteActive = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(darkPool, note, signature) {
+    var nullifier, onChainStatus;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.next = 2;
+          return getNullifier({
+            rho: note.rho,
+            signedMessage: signature
+          });
+        case 2:
+          nullifier = _context4.sent;
+          _context4.next = 5;
+          return getNoteOnChainStatus(darkPool, hexlify32(note.note), nullifier);
+        case 5:
+          onChainStatus = _context4.sent;
+          return _context4.abrupt("return", onChainStatus === NoteOnChainStatus.ACTIVE);
+        case 7:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _isNoteActive.apply(this, arguments);
+}
+function isNoteSpent(_x13, _x14, _x15) {
+  return _isNoteSpent.apply(this, arguments);
+}
+function _isNoteSpent() {
+  _isNoteSpent = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(darkPool, note, signature) {
+    var nullifier, onChainStatus;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.next = 2;
+          return getNullifier({
+            rho: note.rho,
+            signedMessage: signature
+          });
+        case 2:
+          nullifier = _context5.sent;
+          _context5.next = 5;
+          return getNoteOnChainStatus(darkPool, hexlify32(note.note), nullifier);
+        case 5:
+          onChainStatus = _context5.sent;
+          return _context5.abrupt("return", onChainStatus === NoteOnChainStatus.SPENT);
+        case 7:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _isNoteSpent.apply(this, arguments);
+}
+function isNoteLocked(_x16, _x17, _x18) {
+  return _isNoteLocked.apply(this, arguments);
+}
+function _isNoteLocked() {
+  _isNoteLocked = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(darkPool, note, signature) {
+    var nullifier, onChainStatus;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.next = 2;
+          return getNullifier({
+            rho: note.rho,
+            signedMessage: signature
+          });
+        case 2:
+          nullifier = _context6.sent;
+          _context6.next = 5;
+          return getNoteOnChainStatus(darkPool, hexlify32(note.note), nullifier);
+        case 5:
+          onChainStatus = _context6.sent;
+          return _context6.abrupt("return", onChainStatus === NoteOnChainStatus.LOCKED);
+        case 7:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _isNoteLocked.apply(this, arguments);
+}
+function isNoteValid(_x19, _x20) {
+  return _isNoteValid.apply(this, arguments);
+}
+function _isNoteValid() {
+  _isNoteValid = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(note, signature) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.next = 2;
+          return validateNote(note, signature);
+        case 2:
+          return _context7.abrupt("return", _context7.sent);
+        case 3:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  }));
+  return _isNoteValid.apply(this, arguments);
+}
+function isNftNoteValid(_x21, _x22) {
+  return _isNftNoteValid.apply(this, arguments);
+}
+function _isNftNoteValid() {
+  _isNftNoteValid = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(note, signature) {
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _context8.next = 2;
+          return validateNote(note, signature);
+        case 2:
+          return _context8.abrupt("return", _context8.sent);
+        case 3:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  }));
+  return _isNftNoteValid.apply(this, arguments);
+}
+
+var _contractConfig;
+var contractConfig = (_contractConfig = {}, _contractConfig[ChainId.MAINNET] = {
+  priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
+  ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+  nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+  complianceManager: '0x630aD89523a18fA30F752297F3F53B7BC363488b',
+  merkleTreeOperator: '0x152f1051c8D37Fba9A362Fc9b32a0eeF8496202F',
+  darkpoolAssetManager: '0x159F3668c72BBeCdF1fb31beeD606Ec9649654eB',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0xB8096ecD7d3185b24AA218C509175185C11f13a9',
+  stakingOperator: '0x539bcbc08F2cA42E50887dA4Db0DC34EbF0B090b',
+  stakingAssetManager: '0x1Fa7Cb4925086128f3bb9e26761C9C75dbAC3CD1',
+  batchJoinSplitAssetManager: '0x1346b13Ff3Bd19d882E2491cBdAb2DbFc59982E3',
+  darkpoolSwapAssetManager: '0x0',
+  nftAssetManager: '0xbB0679f6831Ee3736AE53D8fcECB9c0e684615d0',
+  drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-subgraph/version/v0.0.1/api',
+  uniswapConfig: {
+    swapRouterAddress: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    quoterContractAddress: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+    wrappedNativeTokenAddress: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    v3PosNftAddress: '0xC36442b4a4522E871399CD717aBDD847Ab11FE88',
+    factoryAddress: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
+    subgraphUrl: 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3?source=uniswap'
+  }
+}, _contractConfig[ChainId.ARBITRUM_ONE] = {
+  priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
+  ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+  nativeWrapper: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+  stakingOperator: '0xF4f1D4F28Be82D81135c13D255452B8325B585B0',
+  stakingAssetManager: '0xB1CC5D9227323330E8a58e891c123B38D03f0BAA',
+  complianceManager: '0x23A37b553c46f4864537Ab1e8d1e49804b47A5A7',
+  merkleTreeOperator: '0x0e2aCb73EBB02bd4099d495bcb96F7522F84ddb7',
+  darkpoolAssetManager: '0xf7C40b5057a1D1a3d58B02BCdb125E63ef380564',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0xcbFA6BB3eb4Bd9BF97866baE75FfB62f3aE897c0',
+  batchJoinSplitAssetManager: '0xd39EA1e275ee468f977f93134a564aF76696E0fE',
+  darkpoolSwapAssetManager: '0x0',
+  nftAssetManager: '0x143242Ff430620a3FA3f9fEaB576050fb20C63BB',
+  drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-arb-subgraph/api'
+}, _contractConfig[ChainId.BounceBit] = {
+  priceOracle: '0x0',
+  ethAddress: '0x0000000000000000000000000000000000000000',
+  nativeWrapper: '0xF4c20e5004C6FDCDdA920bDD491ba8C98a9c5863',
+  stakingOperator: '0x4d459dDe25707CA353De15CC3B85b7C2e4bb380c',
+  stakingAssetManager: '0xe6B0a94e1eA206B122a11a30dA7FB9ADaA12ef42',
+  complianceManager: '0x1Fe002A6E413C70D5CB8477cDaA0422fc7611fCc',
+  merkleTreeOperator: '0x159F3668c72BBeCdF1fb31beeD606Ec9649654eB',
+  darkpoolAssetManager: '0x722133fBb559E2849e3402De3279Bd3059b7fe4E',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0xAa5e02284d1Fd0f6C12AFBDABc28Ed5aC5a6474b',
+  batchJoinSplitAssetManager: '0x0',
+  darkpoolSwapAssetManager: '0x0',
+  nftAssetManager: '0x0',
+  drakpoolSubgraphUrl: 'https://bb.subgraph.thesingularity.network/subgraphs/name/singularity/'
+}, _contractConfig[ChainId.BASE] = {
+  priceOracle: '0xf224a25453D76A41c4427DD1C05369BC9f498444',
+  ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+  nativeWrapper: '0x4200000000000000000000000000000000000006',
+  complianceManager: '0xFa368E046B4051582662f7d1C033756dB55058cF',
+  merkleTreeOperator: '0xdcd767f6f877B4Ef85d631f23e51ff3a2BCC9378',
+  darkpoolAssetManager: '0x84eb120A35802460484015e6748375369e40468a',
+  transferAssetManager: '0x0',
+  stakingOperator: '0xfdA33b941E6C014bD079C6917b815EFA58976f37',
+  stakingAssetManager: '0xa3d27E1Ca5057372478011FB781479B8A1fF7AA3',
+  otcSwapAssetManager: '0x3D76Fd85FCc2593970d22Aa34bcC4c5444c57c9D',
+  batchJoinSplitAssetManager: '0x7b497A97EC69621019fc7eC3D5EF06859AfEBaf1',
+  darkpoolSwapAssetManager: '0x0',
+  nftAssetManager: '0xC4e979C922E93938dBaBb6e1623a19cbc6132489',
+  drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-base-subgraph/api'
+}, _contractConfig[ChainId.SEPOLIA] = {
+  priceOracle: '0x4Fe44a9aC8Ef059Be2dB97f9e3bcA32Ab698C2f2',
+  ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+  nativeWrapper: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
+  stakingOperator: '0xca7081e8C689C2BA887cEaCcfCB1961716CF5fc9',
+  stakingAssetManager: '0x5041cad705244626E8BB9bd6D828b94EEAB09D8b',
+  complianceManager: '0x08DD9cEf89923EDa02F56a4d4aB3FC4a96531443',
+  merkleTreeOperator: '0x84026d6f3b6A4cEa7AD00Cd5154a8537129B3742',
+  darkpoolAssetManager: '0xa10d309818527C8D8F5164f9D640515d6616bFeE',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0x549f3bAD265A0383394E0ABEC7b67b4ff750d2ca',
+  batchJoinSplitAssetManager: '0x31816E27809fdc3cF73539d761133a301beEb9B0',
+  darkpoolSwapAssetManager: '0x802ae625C2bdac1873B8bbb709679CC401F57abc',
+  nftAssetManager: '0x0',
+  drakpoolSubgraphUrl: ''
+}, _contractConfig[ChainId.BounceBitTestnet] = {
+  priceOracle: '0x0',
+  ethAddress: '0x0000000000000000000000000000000000000000',
+  nativeWrapper: '0x0',
+  stakingOperator: '0xEF8F70bB29DEAd5CEcaE26C6Cb19B987475B3e48',
+  stakingAssetManager: '0x30cAA40e8D8d00fEAFc05732Ed75856f5eC7F89c',
+  complianceManager: '0x1Fa7Cb4925086128f3bb9e26761C9C75dbAC3CD1',
+  merkleTreeOperator: '0x40FecD96e94c3c2eE0Fb8bE5cE7073Bb3fB46F51',
+  darkpoolAssetManager: '0xf21f124F395271e8435A93063AE2AD74829D7b69',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0x0',
+  batchJoinSplitAssetManager: '0x0',
+  darkpoolSwapAssetManager: '0x0',
+  nftAssetManager: '0x0',
+  drakpoolSubgraphUrl: ''
+}, _contractConfig[ChainId.HARDHAT] = {
+  priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
+  ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+  nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+  merkleTreeOperator: '0xCC5Bc84C3FDbcF262AaDD9F76652D6784293dD9e',
+  complianceManager: '0x987Aa6E80e995d6A76C4d061eE324fc760Ea9F61',
+  darkpoolAssetManager: '0xe24e7570Fe7207AdAaAa8c6c89a59850391B5276',
+  transferAssetManager: '0x0',
+  otcSwapAssetManager: '0x26Df0Ea798971A97Ae121514B32999DfDb220e1f',
+  stakingOperator: '0x6B9C4119796C80Ced5a3884027985Fd31830555b',
+  stakingAssetManager: '0xCd9BC6cE45194398d12e27e1333D5e1d783104dD',
+  batchJoinSplitAssetManager: '0x0',
+  darkpoolSwapAssetManager: '0x0',
+  theDeepAssetManager: '0x0',
+  nftAssetManager: '0x886a2A3ABF5B79AA5dFF1C73016BD07CFc817e04',
+  drakpoolSubgraphUrl: 'https://34.142.142.240:8080/subgraphs/name/singularity/',
+  uniswapConfig: {
+    swapRouterAddress: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    quoterContractAddress: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+    wrappedNativeTokenAddress: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    v3PosNftAddress: '0xC36442b4a4522E871399CD717aBDD847Ab11FE88',
+    factoryAddress: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
+    subgraphUrl: 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3?source=uniswap'
+  },
+  sablierConfig: {
+    aliasPrefixLinear: 'LL2',
+    aliasPrefixDynamic: 'LD2',
+    lockupLinear: '0xAFb979d9afAd1aD27C5eFf4E27226E3AB9e5dCC9',
+    lockupDynamic: '0x7CC7e125d83A581ff438608490Cc0f7bDff79127',
+    sablierDynamicAssetManager: '0x453439300B6C5C645737324b990f2d51137027bC',
+    sablierLinearAssetManager: '0xB90AcF57C3BFE8e0E8215defc282B5F48b3edC74'
+  }
+}, _contractConfig);
+
+var _stakingTokenConfig;
+var stakingTokenConfig = (_stakingTokenConfig = {}, _stakingTokenConfig[ChainId.MAINNET] = [{
+  originalToken: {
+    address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    decimals: 18,
+    symbol: 'ETH',
+    name: 'Ethereum'
+  },
+  stakingToken: {
+    address: '0x1Df4fAe6CC88A19825dA7dCF8Fcac8E44BA14D2C',
+    decimals: 18,
+    symbol: 'sgETH',
+    name: 'sgETH'
+  }
+}, {
+  originalToken: {
+    address: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
+    decimals: 18,
+    symbol: 'stETH',
+    name: 'Lido Staked Ether'
+  },
+  stakingToken: {
+    address: '0xe397804A9Ff78329997A2b07aF91D484f78e77Be',
+    decimals: 18,
+    symbol: 'sgSTETH',
+    name: 'sgSTETH'
+  }
+}, {
+  originalToken: {
+    address: '0xae78736cd615f374d3085123a210448e74fc6393',
+    decimals: 18,
+    symbol: 'rETH',
+    name: 'Rocket Pool ETH'
+  },
+  stakingToken: {
+    address: '0xA8B78eFF928c30e43A60d8920d1549177652045d',
+    decimals: 18,
+    symbol: 'sgRETH',
+    name: 'sgRETH'
+  }
+}, {
+  originalToken: {
+    address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
+    decimals: 6,
+    symbol: 'USDT',
+    name: 'Tether USD'
+  },
+  stakingToken: {
+    address: '0x91605474f1774f3C1401291A265fa8A995effeb2',
+    decimals: 6,
+    symbol: 'sgUSDT',
+    name: 'sgUSDT'
+  }
+}, {
+  originalToken: {
+    address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin'
+  },
+  stakingToken: {
+    address: '0x0692623f022a622b9CB33ffBEe6c14c8abebf4cc',
+    decimals: 6,
+    symbol: 'sgUSDC',
+    name: 'sgUSDC'
+  }
+}], _stakingTokenConfig[ChainId.ARBITRUM_ONE] = [{
+  originalToken: {
+    address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    decimals: 18,
+    symbol: 'ETH',
+    name: 'Ethereum'
+  },
+  stakingToken: {
+    address: '0xB2393C436a29edc40BA90b9944edB84466565E0c',
+    decimals: 18,
+    symbol: 'sgETH',
+    name: 'sgETH'
+  }
+}, {
+  originalToken: {
+    address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
+    decimals: 6,
+    symbol: 'USDT',
+    name: 'Tether USD'
+  },
+  stakingToken: {
+    address: '0xAB5a3Ab2ef9a03de376CAce74c901a0fccD2A06d',
+    decimals: 6,
+    symbol: 'sgUSDT',
+    name: 'sgUSDT'
+  }
+}, {
+  originalToken: {
+    address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin'
+  },
+  stakingToken: {
+    address: '0xFB6C93eF0B515d041b0DcDF427657E41DDDB8Da8',
+    decimals: 6,
+    symbol: 'sgUSDC',
+    name: 'sgUSDC'
+  }
+}], _stakingTokenConfig[ChainId.BASE] = [], _stakingTokenConfig[ChainId.SEPOLIA] = [{
+  originalToken: {
+    address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    decimals: 18,
+    symbol: 'ETH',
+    name: 'Ethereum'
+  },
+  stakingToken: {
+    address: '0x56fBD5d5C3e9D5f9Ae916F113232d52e6E377E71',
+    decimals: 18,
+    symbol: 'sgETH',
+    name: 'sgETH'
+  }
+}], _stakingTokenConfig[ChainId.BounceBit] = [{
+  originalToken: {
+    address: '0x0000000000000000000000000000000000000000',
+    decimals: 18,
+    symbol: 'BB',
+    name: 'BB'
+  },
+  stakingToken: {
+    address: '0x5D873095152b921222241c0Cbd82d83b47bB31D3',
+    decimals: 18,
+    symbol: 'sgBB',
+    name: 'sgBB'
+  }
+}, {
+  originalToken: {
+    address: '0xF5e11df1ebCf78b6b6D26E04FF19cD786a1e81dC',
+    decimals: 18,
+    symbol: 'BBTC',
+    name: 'BBTC'
+  },
+  stakingToken: {
+    address: '0x578A43b97a9c46b13B153Df6AA05393b78E241Ee',
+    decimals: 18,
+    symbol: 'sgBBTC',
+    name: 'sgBBTC'
+  }
+}, {
+  originalToken: {
+    address: '0x77776b40C3d75cb07ce54dEA4b2Fd1D07F865222',
+    decimals: 18,
+    symbol: 'BBUSD',
+    name: 'BBUSD'
+  },
+  stakingToken: {
+    address: '0x9af2DDB1E3A30442f590f659e13a243Da15C86A0',
+    decimals: 18,
+    symbol: 'sgBBUSDC',
+    name: 'sgBBUSDC'
+  }
+}, {
+  originalToken: {
+    address: '0x22aAC17E571D6651880d057e310703fF4C7c3483',
+    decimals: 18,
+    symbol: 'stBB',
+    name: 'stBB'
+  },
+  stakingToken: {
+    address: '0x3dD11E06DAA99AD255C83545d05Ad27602e0907F',
+    decimals: 18,
+    symbol: 'sgSTBB',
+    name: 'sgSTBB'
+  }
+}], _stakingTokenConfig[ChainId.BounceBitTestnet] = [{
+  originalToken: {
+    address: '0x0000000000000000000000000000000000000000',
+    decimals: 18,
+    symbol: 'BB',
+    name: 'BB'
+  },
+  stakingToken: {
+    address: '0x1276801901cBC847077a8e7e27C973894c86157A',
+    decimals: 18,
+    symbol: 'sgBB',
+    name: 'sgBB'
+  }
+}], _stakingTokenConfig[ChainId.HARDHAT] = [{
+  originalToken: {
+    address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    decimals: 18,
+    symbol: 'ETH',
+    name: 'Ethereum'
+  },
+  stakingToken: {
+    address: '0x5fe2f174fe51474Cd198939C96e7dB65983EA307',
+    decimals: 18,
+    symbol: 'sgETH',
+    name: 'sgETH'
+  }
+}, {
+  originalToken: {
+    address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USDC'
+  },
+  stakingToken: {
+    address: '0x8AFB0C54bAE39A5e56b984DF1C4b5702b2abf205',
+    decimals: 6,
+    symbol: 'sgUSDC',
+    name: 'sgUSDC'
+  }
+}], _stakingTokenConfig);
+
+var DarkPool = /*#__PURE__*/function () {
+  function DarkPool(signer, chainId, relayers, contracts, stakingConfigs, proofOptions) {
+    // @ts-ignore
+    this.signer = signer;
+    // @ts-ignore
+    this.provider = signer.provider;
+    this.chainId = chainId;
+    this.relayers = relayers;
+    if (contracts) {
+      this.contracts = contracts;
+    } else {
+      if (contractConfig[chainId]) {
+        this.contracts = contractConfig[chainId];
+      } else {
+        throw new DarkpoolError('There is no default contract configuration for the provided chainId');
+      }
+    }
+    if (stakingConfigs) {
+      this.stakingConfigs = stakingConfigs;
+    } else {
+      if (stakingTokenConfig[chainId]) {
+        this.stakingConfigs = stakingTokenConfig[chainId];
+      } else {
+        this.stakingConfigs = [];
+      }
+    }
+    if (proofOptions) {
+      this.proofOptions = proofOptions;
+    }
+  }
+  var _proto = DarkPool.prototype;
+  _proto.getRelayer = function getRelayer() {
+    if (this.relayers.length === 0) {
+      throw new DarkpoolError('Relayer is not initialized');
+    }
+    var index = Math.floor(Math.random() * this.relayers.length);
+    return this.relayers[index];
+  };
+  return DarkPool;
+}();
+
+export { BaseContext, BaseContractService, BaseRelayerContext, BaseRelayerService, DarkPool, DarkpoolError, DepositContext, DepositService, NoteOnChainStatus, WithdrawService, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, getNoteOnChainStatusBySignature, hexlify1, hexlify16, hexlify3, hexlify32, hexlify5, hexlify8, isAddressEquals, isHexEquals, isNativeAsset, isNftNoteValid, isNoteActive, isNoteLocked, isNoteSpent, isNoteValid, multiGetMerklePathAndRoot, transferCodeToNoteFooter, validateRecipientCode };
+//# sourceMappingURL=singularity-sdk-lite.esm.js.map