@cetusprotocol/aggregator-sdk 0.0.8 → 0.1.1

package/dist/index.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var client = require('@mysten/sui/client');
 var utils = require('@mysten/sui/utils');
 var transactions = require('@mysten/sui/transactions');
 
@@ -88,8 +87,8 @@ var require_bn = __commonJS({
         ctor.prototype = new TempCtor();
         ctor.prototype.constructor = ctor;
       }
-      function BN5(number, base, endian) {
-        if (BN5.isBN(number)) {
+      function BN6(number, base, endian) {
+        if (BN6.isBN(number)) {
           return number;
         }
         this.negative = 0;
@@ -105,12 +104,12 @@ var require_bn = __commonJS({
         }
       }
       if (typeof module2 === "object") {
-        module2.exports = BN5;
+        module2.exports = BN6;
       } else {
-        exports2.BN = BN5;
+        exports2.BN = BN6;
       }
-      BN5.BN = BN5;
-      BN5.wordSize = 26;
+      BN6.BN = BN6;
+      BN6.wordSize = 26;
       var Buffer2;
       try {
         if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
@@ -120,21 +119,21 @@ var require_bn = __commonJS({
         }
       } catch (e) {
       }
-      BN5.isBN = function isBN(num) {
-        if (num instanceof BN5) {
+      BN6.isBN = function isBN(num) {
+        if (num instanceof BN6) {
           return true;
         }
-        return num !== null && typeof num === "object" && num.constructor.wordSize === BN5.wordSize && Array.isArray(num.words);
+        return num !== null && typeof num === "object" && num.constructor.wordSize === BN6.wordSize && Array.isArray(num.words);
       };
-      BN5.max = function max2(left, right) {
+      BN6.max = function max2(left, right) {
         if (left.cmp(right) > 0) return left;
         return right;
       };
-      BN5.min = function min2(left, right) {
+      BN6.min = function min2(left, right) {
         if (left.cmp(right) < 0) return left;
         return right;
       };
-      BN5.prototype._init = function init(number, base, endian) {
+      BN6.prototype._init = function init(number, base, endian) {
         if (typeof number === "number") {
           return this._initNumber(number, base, endian);
         }
@@ -162,7 +161,7 @@ var require_bn = __commonJS({
           }
         }
       };
-      BN5.prototype._initNumber = function _initNumber(number, base, endian) {
+      BN6.prototype._initNumber = function _initNumber(number, base, endian) {
         if (number < 0) {
           this.negative = 1;
           number = -number;
@@ -188,7 +187,7 @@ var require_bn = __commonJS({
         if (endian !== "le") return;
         this._initArray(this.toArray(), base, endian);
       };
-      BN5.prototype._initArray = function _initArray(number, base, endian) {
+      BN6.prototype._initArray = function _initArray(number, base, endian) {
         assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
@@ -246,7 +245,7 @@ var require_bn = __commonJS({
         }
         return r;
       }
-      BN5.prototype._parseHex = function _parseHex(number, start, endian) {
+      BN6.prototype._parseHex = function _parseHex(number, start, endian) {
         this.length = Math.ceil((number.length - start) / 6);
         this.words = new Array(this.length);
         for (var i = 0; i < this.length; i++) {
@@ -302,7 +301,7 @@ var require_bn = __commonJS({
         }
         return r;
       }
-      BN5.prototype._parseBase = function _parseBase(number, base, start) {
+      BN6.prototype._parseBase = function _parseBase(number, base, start) {
         this.words = [0];
         this.length = 1;
         for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
@@ -338,7 +337,7 @@ var require_bn = __commonJS({
         }
         this._strip();
       };
-      BN5.prototype.copy = function copy(dest) {
+      BN6.prototype.copy = function copy(dest) {
         dest.words = new Array(this.length);
         for (var i = 0; i < this.length; i++) {
           dest.words[i] = this.words[i];
@@ -353,27 +352,27 @@ var require_bn = __commonJS({
         dest.negative = src.negative;
         dest.red = src.red;
       }
-      BN5.prototype._move = function _move(dest) {
+      BN6.prototype._move = function _move(dest) {
         move(dest, this);
       };
-      BN5.prototype.clone = function clone2() {
-        var r = new BN5(null);
+      BN6.prototype.clone = function clone2() {
+        var r = new BN6(null);
         this.copy(r);
         return r;
       };
-      BN5.prototype._expand = function _expand(size) {
+      BN6.prototype._expand = function _expand(size) {
         while (this.length < size) {
           this.words[this.length++] = 0;
         }
         return this;
       };
-      BN5.prototype._strip = function strip() {
+      BN6.prototype._strip = function strip() {
         while (this.length > 1 && this.words[this.length - 1] === 0) {
           this.length--;
         }
         return this._normSign();
       };
-      BN5.prototype._normSign = function _normSign() {
+      BN6.prototype._normSign = function _normSign() {
         if (this.length === 1 && this.words[0] === 0) {
           this.negative = 0;
         }
@@ -381,12 +380,12 @@ var require_bn = __commonJS({
       };
       if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
         try {
-          BN5.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
+          BN6.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
         } catch (e) {
-          BN5.prototype.inspect = inspect;
+          BN6.prototype.inspect = inspect;
         }
       } else {
-        BN5.prototype.inspect = inspect;
+        BN6.prototype.inspect = inspect;
       }
       function inspect() {
         return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
@@ -497,7 +496,7 @@ var require_bn = __commonJS({
         52521875,
         60466176
       ];
-      BN5.prototype.toString = function toString(base, padding) {
+      BN6.prototype.toString = function toString(base, padding) {
         base = base || 10;
         padding = padding | 0 || 1;
         var out;
@@ -559,7 +558,7 @@ var require_bn = __commonJS({
         }
         assert(false, "Base should be between 2 and 36");
       };
-      BN5.prototype.toNumber = function toNumber() {
+      BN6.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
         if (this.length === 2) {
           ret += this.words[1] * 67108864;
@@ -570,15 +569,15 @@ var require_bn = __commonJS({
         }
         return this.negative !== 0 ? -ret : ret;
       };
-      BN5.prototype.toJSON = function toJSON() {
+      BN6.prototype.toJSON = function toJSON() {
         return this.toString(16, 2);
       };
       if (Buffer2) {
-        BN5.prototype.toBuffer = function toBuffer(endian, length) {
+        BN6.prototype.toBuffer = function toBuffer(endian, length) {
           return this.toArrayLike(Buffer2, endian, length);
         };
       }
-      BN5.prototype.toArray = function toArray(endian, length) {
+      BN6.prototype.toArray = function toArray(endian, length) {
         return this.toArrayLike(Array, endian, length);
       };
       var allocate = function allocate2(ArrayType, size) {
@@ -587,7 +586,7 @@ var require_bn = __commonJS({
         }
         return new ArrayType(size);
       };
-      BN5.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
+      BN6.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
         this._strip();
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
@@ -598,7 +597,7 @@ var require_bn = __commonJS({
         this["_toArrayLike" + postfix](res, byteLength);
         return res;
       };
-      BN5.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
+      BN6.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
         var position = 0;
         var carry = 0;
         for (var i = 0, shift = 0; i < this.length; i++) {
@@ -628,7 +627,7 @@ var require_bn = __commonJS({
           }
         }
       };
-      BN5.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
+      BN6.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
         var position = res.length - 1;
         var carry = 0;
         for (var i = 0, shift = 0; i < this.length; i++) {
@@ -659,11 +658,11 @@ var require_bn = __commonJS({
         }
       };
       if (Math.clz32) {
-        BN5.prototype._countBits = function _countBits(w) {
+        BN6.prototype._countBits = function _countBits(w) {
           return 32 - Math.clz32(w);
         };
       } else {
-        BN5.prototype._countBits = function _countBits(w) {
+        BN6.prototype._countBits = function _countBits(w) {
           var t = w;
           var r = 0;
           if (t >= 4096) {
@@ -685,7 +684,7 @@ var require_bn = __commonJS({
           return r + t;
         };
       }
-      BN5.prototype._zeroBits = function _zeroBits(w) {
+      BN6.prototype._zeroBits = function _zeroBits(w) {
         if (w === 0) return 26;
         var t = w;
         var r = 0;
@@ -710,7 +709,7 @@ var require_bn = __commonJS({
         }
         return r;
       };
-      BN5.prototype.bitLength = function bitLength() {
+      BN6.prototype.bitLength = function bitLength() {
         var w = this.words[this.length - 1];
         var hi = this._countBits(w);
         return (this.length - 1) * 26 + hi;
@@ -724,7 +723,7 @@ var require_bn = __commonJS({
         }
         return w;
       }
-      BN5.prototype.zeroBits = function zeroBits() {
+      BN6.prototype.zeroBits = function zeroBits() {
         if (this.isZero()) return 0;
         var r = 0;
         for (var i = 0; i < this.length; i++) {
@@ -734,34 +733,34 @@ var require_bn = __commonJS({
         }
         return r;
       };
-      BN5.prototype.byteLength = function byteLength() {
+      BN6.prototype.byteLength = function byteLength() {
         return Math.ceil(this.bitLength() / 8);
       };
-      BN5.prototype.toTwos = function toTwos(width) {
+      BN6.prototype.toTwos = function toTwos(width) {
         if (this.negative !== 0) {
           return this.abs().inotn(width).iaddn(1);
         }
         return this.clone();
       };
-      BN5.prototype.fromTwos = function fromTwos(width) {
+      BN6.prototype.fromTwos = function fromTwos(width) {
         if (this.testn(width - 1)) {
           return this.notn(width).iaddn(1).ineg();
         }
         return this.clone();
       };
-      BN5.prototype.isNeg = function isNeg() {
+      BN6.prototype.isNeg = function isNeg() {
         return this.negative !== 0;
       };
-      BN5.prototype.neg = function neg() {
+      BN6.prototype.neg = function neg() {
         return this.clone().ineg();
       };
-      BN5.prototype.ineg = function ineg() {
+      BN6.prototype.ineg = function ineg() {
         if (!this.isZero()) {
           this.negative ^= 1;
         }
         return this;
       };
-      BN5.prototype.iuor = function iuor(num) {
+      BN6.prototype.iuor = function iuor(num) {
         while (this.length < num.length) {
           this.words[this.length++] = 0;
         }
@@ -770,19 +769,19 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.ior = function ior(num) {
+      BN6.prototype.ior = function ior(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
-      BN5.prototype.or = function or(num) {
+      BN6.prototype.or = function or(num) {
         if (this.length > num.length) return this.clone().ior(num);
         return num.clone().ior(this);
       };
-      BN5.prototype.uor = function uor(num) {
+      BN6.prototype.uor = function uor(num) {
         if (this.length > num.length) return this.clone().iuor(num);
         return num.clone().iuor(this);
       };
-      BN5.prototype.iuand = function iuand(num) {
+      BN6.prototype.iuand = function iuand(num) {
         var b;
         if (this.length > num.length) {
           b = num;
@@ -795,19 +794,19 @@ var require_bn = __commonJS({
         this.length = b.length;
         return this._strip();
       };
-      BN5.prototype.iand = function iand(num) {
+      BN6.prototype.iand = function iand(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
-      BN5.prototype.and = function and(num) {
+      BN6.prototype.and = function and(num) {
         if (this.length > num.length) return this.clone().iand(num);
         return num.clone().iand(this);
       };
-      BN5.prototype.uand = function uand(num) {
+      BN6.prototype.uand = function uand(num) {
         if (this.length > num.length) return this.clone().iuand(num);
         return num.clone().iuand(this);
       };
-      BN5.prototype.iuxor = function iuxor(num) {
+      BN6.prototype.iuxor = function iuxor(num) {
         var a;
         var b;
         if (this.length > num.length) {
@@ -828,19 +827,19 @@ var require_bn = __commonJS({
         this.length = a.length;
         return this._strip();
       };
-      BN5.prototype.ixor = function ixor(num) {
+      BN6.prototype.ixor = function ixor(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
-      BN5.prototype.xor = function xor(num) {
+      BN6.prototype.xor = function xor(num) {
         if (this.length > num.length) return this.clone().ixor(num);
         return num.clone().ixor(this);
       };
-      BN5.prototype.uxor = function uxor(num) {
+      BN6.prototype.uxor = function uxor(num) {
         if (this.length > num.length) return this.clone().iuxor(num);
         return num.clone().iuxor(this);
       };
-      BN5.prototype.inotn = function inotn(width) {
+      BN6.prototype.inotn = function inotn(width) {
         assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
@@ -856,10 +855,10 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.notn = function notn(width) {
+      BN6.prototype.notn = function notn(width) {
         return this.clone().inotn(width);
       };
-      BN5.prototype.setn = function setn(bit, val) {
+      BN6.prototype.setn = function setn(bit, val) {
         assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
@@ -871,7 +870,7 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.iadd = function iadd(num) {
+      BN6.prototype.iadd = function iadd(num) {
         var r;
         if (this.negative !== 0 && num.negative === 0) {
           this.negative = 0;
@@ -914,7 +913,7 @@ var require_bn = __commonJS({
         }
         return this;
       };
-      BN5.prototype.add = function add2(num) {
+      BN6.prototype.add = function add2(num) {
         var res;
         if (num.negative !== 0 && this.negative === 0) {
           num.negative = 0;
@@ -930,7 +929,7 @@ var require_bn = __commonJS({
         if (this.length > num.length) return this.clone().iadd(num);
         return num.clone().iadd(this);
       };
-      BN5.prototype.isub = function isub(num) {
+      BN6.prototype.isub = function isub(num) {
         if (num.negative !== 0) {
           num.negative = 0;
           var r = this.iadd(num);
@@ -979,7 +978,7 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.sub = function sub2(num) {
+      BN6.prototype.sub = function sub2(num) {
         return this.clone().isub(num);
       };
       function smallMulTo(self, num, out) {
@@ -1607,7 +1606,7 @@ var require_bn = __commonJS({
       function jumboMulTo(self, num, out) {
         return bigMulTo(self, num, out);
       }
-      BN5.prototype.mulTo = function mulTo(num, out) {
+      BN6.prototype.mulTo = function mulTo(num, out) {
         var res;
         var len = this.length + num.length;
         if (this.length === 10 && num.length === 10) {
@@ -1621,20 +1620,20 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN5.prototype.mul = function mul2(num) {
-        var out = new BN5(null);
+      BN6.prototype.mul = function mul2(num) {
+        var out = new BN6(null);
         out.words = new Array(this.length + num.length);
         return this.mulTo(num, out);
       };
-      BN5.prototype.mulf = function mulf(num) {
-        var out = new BN5(null);
+      BN6.prototype.mulf = function mulf(num) {
+        var out = new BN6(null);
         out.words = new Array(this.length + num.length);
         return jumboMulTo(this, num, out);
       };
-      BN5.prototype.imul = function imul(num) {
+      BN6.prototype.imul = function imul(num) {
         return this.clone().mulTo(num, this);
       };
-      BN5.prototype.imuln = function imuln(num) {
+      BN6.prototype.imuln = function imuln(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(typeof num === "number");
@@ -1654,18 +1653,18 @@ var require_bn = __commonJS({
         }
         return isNegNum ? this.ineg() : this;
       };
-      BN5.prototype.muln = function muln(num) {
+      BN6.prototype.muln = function muln(num) {
         return this.clone().imuln(num);
       };
-      BN5.prototype.sqr = function sqr() {
+      BN6.prototype.sqr = function sqr() {
         return this.mul(this);
       };
-      BN5.prototype.isqr = function isqr() {
+      BN6.prototype.isqr = function isqr() {
         return this.imul(this.clone());
       };
-      BN5.prototype.pow = function pow2(num) {
+      BN6.prototype.pow = function pow2(num) {
         var w = toBitArray(num);
-        if (w.length === 0) return new BN5(1);
+        if (w.length === 0) return new BN6(1);
         var res = this;
         for (var i = 0; i < w.length; i++, res = res.sqr()) {
           if (w[i] !== 0) break;
@@ -1678,7 +1677,7 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN5.prototype.iushln = function iushln(bits) {
+      BN6.prototype.iushln = function iushln(bits) {
         assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
@@ -1708,11 +1707,11 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.ishln = function ishln(bits) {
+      BN6.prototype.ishln = function ishln(bits) {
         assert(this.negative === 0);
         return this.iushln(bits);
       };
-      BN5.prototype.iushrn = function iushrn(bits, hint, extended) {
+      BN6.prototype.iushrn = function iushrn(bits, hint, extended) {
         assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
@@ -1756,23 +1755,23 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.ishrn = function ishrn(bits, hint, extended) {
+      BN6.prototype.ishrn = function ishrn(bits, hint, extended) {
         assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
-      BN5.prototype.shln = function shln(bits) {
+      BN6.prototype.shln = function shln(bits) {
         return this.clone().ishln(bits);
       };
-      BN5.prototype.ushln = function ushln(bits) {
+      BN6.prototype.ushln = function ushln(bits) {
         return this.clone().iushln(bits);
       };
-      BN5.prototype.shrn = function shrn(bits) {
+      BN6.prototype.shrn = function shrn(bits) {
         return this.clone().ishrn(bits);
       };
-      BN5.prototype.ushrn = function ushrn(bits) {
+      BN6.prototype.ushrn = function ushrn(bits) {
         return this.clone().iushrn(bits);
       };
-      BN5.prototype.testn = function testn(bit) {
+      BN6.prototype.testn = function testn(bit) {
         assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
@@ -1781,7 +1780,7 @@ var require_bn = __commonJS({
         var w = this.words[s];
         return !!(w & q);
       };
-      BN5.prototype.imaskn = function imaskn(bits) {
+      BN6.prototype.imaskn = function imaskn(bits) {
         assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
@@ -1799,10 +1798,10 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.maskn = function maskn(bits) {
+      BN6.prototype.maskn = function maskn(bits) {
         return this.clone().imaskn(bits);
       };
-      BN5.prototype.iaddn = function iaddn(num) {
+      BN6.prototype.iaddn = function iaddn(num) {
         assert(typeof num === "number");
         assert(num < 67108864);
         if (num < 0) return this.isubn(-num);
@@ -1819,7 +1818,7 @@ var require_bn = __commonJS({
         }
         return this._iaddn(num);
       };
-      BN5.prototype._iaddn = function _iaddn(num) {
+      BN6.prototype._iaddn = function _iaddn(num) {
         this.words[0] += num;
         for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
           this.words[i] -= 67108864;
@@ -1832,7 +1831,7 @@ var require_bn = __commonJS({
         this.length = Math.max(this.length, i + 1);
         return this;
       };
-      BN5.prototype.isubn = function isubn(num) {
+      BN6.prototype.isubn = function isubn(num) {
         assert(typeof num === "number");
         assert(num < 67108864);
         if (num < 0) return this.iaddn(-num);
@@ -1854,20 +1853,20 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN5.prototype.addn = function addn(num) {
+      BN6.prototype.addn = function addn(num) {
         return this.clone().iaddn(num);
       };
-      BN5.prototype.subn = function subn(num) {
+      BN6.prototype.subn = function subn(num) {
         return this.clone().isubn(num);
       };
-      BN5.prototype.iabs = function iabs() {
+      BN6.prototype.iabs = function iabs() {
         this.negative = 0;
         return this;
       };
-      BN5.prototype.abs = function abs2() {
+      BN6.prototype.abs = function abs2() {
         return this.clone().iabs();
       };
-      BN5.prototype._ishlnsubmul = function _ishlnsubmul(num, mul2, shift) {
+      BN6.prototype._ishlnsubmul = function _ishlnsubmul(num, mul2, shift) {
         var len = num.length + shift;
         var i;
         this._expand(len);
@@ -1896,7 +1895,7 @@ var require_bn = __commonJS({
         this.negative = 1;
         return this._strip();
       };
-      BN5.prototype._wordDiv = function _wordDiv(num, mode) {
+      BN6.prototype._wordDiv = function _wordDiv(num, mode) {
         var shift = this.length - num.length;
         var a = this.clone();
         var b = num;
@@ -1911,7 +1910,7 @@ var require_bn = __commonJS({
         var m = a.length - b.length;
         var q;
         if (mode !== "mod") {
-          q = new BN5(null);
+          q = new BN6(null);
           q.length = m + 1;
           q.words = new Array(q.length);
           for (var i = 0; i < q.length; i++) {
@@ -1953,12 +1952,12 @@ var require_bn = __commonJS({
           mod: a
         };
       };
-      BN5.prototype.divmod = function divmod(num, mode, positive) {
+      BN6.prototype.divmod = function divmod(num, mode, positive) {
         assert(!num.isZero());
         if (this.isZero()) {
           return {
-            div: new BN5(0),
-            mod: new BN5(0)
+            div: new BN6(0),
+            mod: new BN6(0)
           };
         }
         var div2, mod2, res;
@@ -2003,7 +2002,7 @@ var require_bn = __commonJS({
         }
         if (num.length > this.length || this.cmp(num) < 0) {
           return {
-            div: new BN5(0),
+            div: new BN6(0),
             mod: this
           };
         }
@@ -2017,26 +2016,26 @@ var require_bn = __commonJS({
           if (mode === "mod") {
             return {
               div: null,
-              mod: new BN5(this.modrn(num.words[0]))
+              mod: new BN6(this.modrn(num.words[0]))
             };
           }
           return {
             div: this.divn(num.words[0]),
-            mod: new BN5(this.modrn(num.words[0]))
+            mod: new BN6(this.modrn(num.words[0]))
           };
         }
         return this._wordDiv(num, mode);
       };
-      BN5.prototype.div = function div2(num) {
+      BN6.prototype.div = function div2(num) {
         return this.divmod(num, "div", false).div;
       };
-      BN5.prototype.mod = function mod2(num) {
+      BN6.prototype.mod = function mod2(num) {
         return this.divmod(num, "mod", false).mod;
       };
-      BN5.prototype.umod = function umod(num) {
+      BN6.prototype.umod = function umod(num) {
         return this.divmod(num, "mod", true).mod;
       };
-      BN5.prototype.divRound = function divRound(num) {
+      BN6.prototype.divRound = function divRound(num) {
         var dm = this.divmod(num);
         if (dm.mod.isZero()) return dm.div;
         var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
@@ -2046,7 +2045,7 @@ var require_bn = __commonJS({
         if (cmp2 < 0 || r2 === 1 && cmp2 === 0) return dm.div;
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
       };
-      BN5.prototype.modrn = function modrn(num) {
+      BN6.prototype.modrn = function modrn(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(num <= 67108863);
@@ -2057,10 +2056,10 @@ var require_bn = __commonJS({
         }
         return isNegNum ? -acc : acc;
       };
-      BN5.prototype.modn = function modn(num) {
+      BN6.prototype.modn = function modn(num) {
         return this.modrn(num);
       };
-      BN5.prototype.idivn = function idivn(num) {
+      BN6.prototype.idivn = function idivn(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(num <= 67108863);
@@ -2073,10 +2072,10 @@ var require_bn = __commonJS({
         this._strip();
         return isNegNum ? this.ineg() : this;
       };
-      BN5.prototype.divn = function divn(num) {
+      BN6.prototype.divn = function divn(num) {
         return this.clone().idivn(num);
       };
-      BN5.prototype.egcd = function egcd(p) {
+      BN6.prototype.egcd = function egcd(p) {
         assert(p.negative === 0);
         assert(!p.isZero());
         var x = this;
@@ -2086,10 +2085,10 @@ var require_bn = __commonJS({
         } else {
           x = x.clone();
         }
-        var A = new BN5(1);
-        var B = new BN5(0);
-        var C = new BN5(0);
-        var D = new BN5(1);
+        var A = new BN6(1);
+        var B = new BN6(0);
+        var C = new BN6(0);
+        var D = new BN6(1);
         var g = 0;
         while (x.isEven() && y.isEven()) {
           x.iushrn(1);
@@ -2139,7 +2138,7 @@ var require_bn = __commonJS({
           gcd: y.iushln(g)
         };
       };
-      BN5.prototype._invmp = function _invmp(p) {
+      BN6.prototype._invmp = function _invmp(p) {
         assert(p.negative === 0);
         assert(!p.isZero());
         var a = this;
@@ -2149,8 +2148,8 @@ var require_bn = __commonJS({
         } else {
           a = a.clone();
         }
-        var x1 = new BN5(1);
-        var x2 = new BN5(0);
+        var x1 = new BN6(1);
+        var x2 = new BN6(0);
         var delta = b.clone();
         while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
           for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
@@ -2192,7 +2191,7 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN5.prototype.gcd = function gcd(num) {
+      BN6.prototype.gcd = function gcd(num) {
         if (this.isZero()) return num.abs();
         if (num.isZero()) return this.abs();
         var a = this.clone();
@@ -2222,19 +2221,19 @@ var require_bn = __commonJS({
         } while (true);
         return b.iushln(shift);
       };
-      BN5.prototype.invm = function invm(num) {
+      BN6.prototype.invm = function invm(num) {
         return this.egcd(num).a.umod(num);
       };
-      BN5.prototype.isEven = function isEven() {
+      BN6.prototype.isEven = function isEven() {
         return (this.words[0] & 1) === 0;
       };
-      BN5.prototype.isOdd = function isOdd2() {
+      BN6.prototype.isOdd = function isOdd2() {
         return (this.words[0] & 1) === 1;
       };
-      BN5.prototype.andln = function andln(num) {
+      BN6.prototype.andln = function andln(num) {
         return this.words[0] & num;
       };
-      BN5.prototype.bincn = function bincn(bit) {
+      BN6.prototype.bincn = function bincn(bit) {
         assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
@@ -2258,10 +2257,10 @@ var require_bn = __commonJS({
         }
         return this;
       };
-      BN5.prototype.isZero = function isZero() {
+      BN6.prototype.isZero = function isZero() {
         return this.length === 1 && this.words[0] === 0;
       };
-      BN5.prototype.cmpn = function cmpn(num) {
+      BN6.prototype.cmpn = function cmpn(num) {
         var negative = num < 0;
         if (this.negative !== 0 && !negative) return -1;
         if (this.negative === 0 && negative) return 1;
@@ -2280,14 +2279,14 @@ var require_bn = __commonJS({
         if (this.negative !== 0) return -res | 0;
         return res;
       };
-      BN5.prototype.cmp = function cmp2(num) {
+      BN6.prototype.cmp = function cmp2(num) {
         if (this.negative !== 0 && num.negative === 0) return -1;
         if (this.negative === 0 && num.negative !== 0) return 1;
         var res = this.ucmp(num);
         if (this.negative !== 0) return -res | 0;
         return res;
       };
-      BN5.prototype.ucmp = function ucmp(num) {
+      BN6.prototype.ucmp = function ucmp(num) {
         if (this.length > num.length) return 1;
         if (this.length < num.length) return -1;
         var res = 0;
@@ -2304,112 +2303,112 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN5.prototype.gtn = function gtn(num) {
+      BN6.prototype.gtn = function gtn(num) {
         return this.cmpn(num) === 1;
       };
-      BN5.prototype.gt = function gt(num) {
+      BN6.prototype.gt = function gt(num) {
         return this.cmp(num) === 1;
       };
-      BN5.prototype.gten = function gten(num) {
+      BN6.prototype.gten = function gten(num) {
         return this.cmpn(num) >= 0;
       };
-      BN5.prototype.gte = function gte(num) {
+      BN6.prototype.gte = function gte(num) {
         return this.cmp(num) >= 0;
       };
-      BN5.prototype.ltn = function ltn(num) {
+      BN6.prototype.ltn = function ltn(num) {
         return this.cmpn(num) === -1;
       };
-      BN5.prototype.lt = function lt(num) {
+      BN6.prototype.lt = function lt(num) {
         return this.cmp(num) === -1;
       };
-      BN5.prototype.lten = function lten(num) {
+      BN6.prototype.lten = function lten(num) {
         return this.cmpn(num) <= 0;
       };
-      BN5.prototype.lte = function lte(num) {
+      BN6.prototype.lte = function lte(num) {
         return this.cmp(num) <= 0;
       };
-      BN5.prototype.eqn = function eqn(num) {
+      BN6.prototype.eqn = function eqn(num) {
         return this.cmpn(num) === 0;
       };
-      BN5.prototype.eq = function eq(num) {
+      BN6.prototype.eq = function eq(num) {
         return this.cmp(num) === 0;
       };
-      BN5.red = function red(num) {
+      BN6.red = function red(num) {
         return new Red(num);
       };
-      BN5.prototype.toRed = function toRed(ctx) {
+      BN6.prototype.toRed = function toRed(ctx) {
         assert(!this.red, "Already a number in reduction context");
         assert(this.negative === 0, "red works only with positives");
         return ctx.convertTo(this)._forceRed(ctx);
       };
-      BN5.prototype.fromRed = function fromRed() {
+      BN6.prototype.fromRed = function fromRed() {
         assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
-      BN5.prototype._forceRed = function _forceRed(ctx) {
+      BN6.prototype._forceRed = function _forceRed(ctx) {
         this.red = ctx;
         return this;
       };
-      BN5.prototype.forceRed = function forceRed(ctx) {
+      BN6.prototype.forceRed = function forceRed(ctx) {
         assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
-      BN5.prototype.redAdd = function redAdd(num) {
+      BN6.prototype.redAdd = function redAdd(num) {
         assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
-      BN5.prototype.redIAdd = function redIAdd(num) {
+      BN6.prototype.redIAdd = function redIAdd(num) {
         assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
-      BN5.prototype.redSub = function redSub(num) {
+      BN6.prototype.redSub = function redSub(num) {
         assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
-      BN5.prototype.redISub = function redISub(num) {
+      BN6.prototype.redISub = function redISub(num) {
         assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
-      BN5.prototype.redShl = function redShl(num) {
+      BN6.prototype.redShl = function redShl(num) {
         assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
-      BN5.prototype.redMul = function redMul(num) {
+      BN6.prototype.redMul = function redMul(num) {
         assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.mul(this, num);
       };
-      BN5.prototype.redIMul = function redIMul(num) {
+      BN6.prototype.redIMul = function redIMul(num) {
         assert(this.red, "redMul works only with red numbers");
         this.red._verify2(this, num);
         return this.red.imul(this, num);
       };
-      BN5.prototype.redSqr = function redSqr() {
+      BN6.prototype.redSqr = function redSqr() {
         assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
-      BN5.prototype.redISqr = function redISqr() {
+      BN6.prototype.redISqr = function redISqr() {
         assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
-      BN5.prototype.redSqrt = function redSqrt() {
+      BN6.prototype.redSqrt = function redSqrt() {
         assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
-      BN5.prototype.redInvm = function redInvm() {
+      BN6.prototype.redInvm = function redInvm() {
         assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
-      BN5.prototype.redNeg = function redNeg() {
+      BN6.prototype.redNeg = function redNeg() {
         assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
-      BN5.prototype.redPow = function redPow(num) {
+      BN6.prototype.redPow = function redPow(num) {
         assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
@@ -2422,13 +2421,13 @@ var require_bn = __commonJS({
       };
       function MPrime(name, p) {
         this.name = name;
-        this.p = new BN5(p, 16);
+        this.p = new BN6(p, 16);
         this.n = this.p.bitLength();
-        this.k = new BN5(1).iushln(this.n).isub(this.p);
+        this.k = new BN6(1).iushln(this.n).isub(this.p);
         this.tmp = this._tmp();
       }
       MPrime.prototype._tmp = function _tmp() {
-        var tmp = new BN5(null);
+        var tmp = new BN6(null);
         tmp.words = new Array(Math.ceil(this.n / 13));
         return tmp;
       };
@@ -2554,7 +2553,7 @@ var require_bn = __commonJS({
         }
         return num;
       };
-      BN5._prime = function prime(name) {
+      BN6._prime = function prime(name) {
         if (primes[name]) return primes[name];
         var prime2;
         if (name === "k256") {
@@ -2573,7 +2572,7 @@ var require_bn = __commonJS({
       };
       function Red(m) {
         if (typeof m === "string") {
-          var prime = BN5._prime(m);
+          var prime = BN6._prime(m);
           this.m = prime.p;
           this.prime = prime;
         } else {
@@ -2659,7 +2658,7 @@ var require_bn = __commonJS({
         var mod3 = this.m.andln(3);
         assert(mod3 % 2 === 1);
         if (mod3 === 3) {
-          var pow2 = this.m.add(new BN5(1)).iushrn(2);
+          var pow2 = this.m.add(new BN6(1)).iushrn(2);
           return this.pow(a, pow2);
         }
         var q = this.m.subn(1);
@@ -2669,11 +2668,11 @@ var require_bn = __commonJS({
           q.iushrn(1);
         }
         assert(!q.isZero());
-        var one = new BN5(1).toRed(this);
+        var one = new BN6(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
         var z = this.m.bitLength();
-        z = new BN5(2 * z * z).toRed(this);
+        z = new BN6(2 * z * z).toRed(this);
         while (this.pow(z, lpow).cmp(nOne) !== 0) {
           z.redIAdd(nOne);
         }
@@ -2687,7 +2686,7 @@ var require_bn = __commonJS({
             tmp = tmp.redSqr();
           }
           assert(i < m);
-          var b = this.pow(c, new BN5(1).iushln(m - i - 1));
+          var b = this.pow(c, new BN6(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
           t = t.redMul(c);
@@ -2705,11 +2704,11 @@ var require_bn = __commonJS({
         }
       };
       Red.prototype.pow = function pow2(a, num) {
-        if (num.isZero()) return new BN5(1).toRed(this);
+        if (num.isZero()) return new BN6(1).toRed(this);
         if (num.cmpn(1) === 0) return a.clone();
         var windowSize = 4;
         var wnd = new Array(1 << windowSize);
-        wnd[0] = new BN5(1).toRed(this);
+        wnd[0] = new BN6(1).toRed(this);
         wnd[1] = a;
         for (var i = 2; i < wnd.length; i++) {
           wnd[i] = this.mul(wnd[i - 1], a);
@@ -2753,7 +2752,7 @@ var require_bn = __commonJS({
         res.red = null;
         return res;
       };
-      BN5.mont = function mont(num) {
+      BN6.mont = function mont(num) {
         return new Mont(num);
       };
       function Mont(m) {
@@ -2762,7 +2761,7 @@ var require_bn = __commonJS({
         if (this.shift % 26 !== 0) {
           this.shift += 26 - this.shift % 26;
         }
-        this.r = new BN5(1).iushln(this.shift);
+        this.r = new BN6(1).iushln(this.shift);
         this.r2 = this.imod(this.r.sqr());
         this.rinv = this.r._invmp(this.m);
         this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
@@ -2796,7 +2795,7 @@ var require_bn = __commonJS({
         return res._forceRed(this);
       };
       Mont.prototype.mul = function mul2(a, b) {
-        if (a.isZero() || b.isZero()) return new BN5(0)._forceRed(this);
+        if (a.isZero() || b.isZero()) return new BN6(0)._forceRed(this);
         var t = a.mul(b);
         var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
         var u = t.isub(c).iushrn(this.shift);
@@ -4980,6 +4979,402 @@ LN10 = new Decimal(LN10);
 PI = new Decimal(PI);
 var decimal_default = Decimal;
 
+// src/client.ts
+var import_bn5 = __toESM(require_bn());
+
+// src/transaction/aftermath.ts
+var import_bn = __toESM(require_bn());
+var Aftermath = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Aftermath only supported on mainnet");
+    }
+    this.slippage = "900000000000000000";
+    this.poolRegistry = "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae";
+    this.protocolFeeVault = "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4";
+    this.treasury = "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce";
+    this.insuranceFund = "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b";
+    this.referrealVault = "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278";
+  }
+  amountLimit(exportAmountOut) {
+    return Number(
+      new import_bn.default(exportAmountOut).mul(new import_bn.default(this.slippage)).div(new import_bn.default("1000000000000000000")).toString()
+    );
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      if (path.extendedDetails == null) {
+        throw new Error("Extended details not supported");
+      } else {
+        if (path.extendedDetails.aftermathLpSupplyType == null) {
+          throw new Error("LP supply type not supported");
+        }
+      }
+      const args = [
+        txb.object(path.id),
+        txb.object(this.poolRegistry),
+        txb.object(this.protocolFeeVault),
+        txb.object(this.treasury),
+        txb.object(this.insuranceFund),
+        txb.object(this.referrealVault),
+        txb.pure.u64(this.amountLimit(path.amountOut)),
+        txb.pure.u64(this.slippage),
+        inputCoin
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::aftermath::${func}`,
+        typeArguments: [
+          coinAType,
+          coinBType,
+          path.extendedDetails.aftermathLpSupplyType
+        ],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/deepbook_v2.ts
+var DEEPBOOK_PACKAGE_ID = "0x000000000000000000000000000000000000000000000000000000000000dee9";
+var DeepbookV2 = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Aftermath only supported on mainnet");
+    }
+  }
+  getAccountCap(client, owner) {
+    return __async(this, null, function* () {
+      let limit = 50;
+      let cursor = null;
+      while (true) {
+        const ownedObjects = client.getOwnedObjects({
+          owner,
+          cursor,
+          limit,
+          filter: {
+            MoveModule: {
+              package: DEEPBOOK_PACKAGE_ID,
+              module: "custodian_v2"
+            }
+          }
+        });
+        if (ownedObjects != null && ownedObjects.data != null) {
+          if (ownedObjects.data.length !== 0) {
+            return ownedObjects.data[0].data.objectId;
+          }
+          if (ownedObjects.data.length < 50) {
+            break;
+          }
+        } else {
+          break;
+        }
+      }
+      return null;
+    });
+  }
+  getOrCreateAccountCap(txb, client, owner) {
+    return __async(this, null, function* () {
+      let accountCapStr = yield this.getAccountCap(client, owner);
+      if (accountCapStr !== null) {
+        return {
+          accountCap: txb.object(accountCapStr),
+          isCreate: false
+        };
+      }
+      const accountCap = txb.moveCall({
+        target: `${DEEPBOOK_PACKAGE_ID}::clob_v2::create_account`,
+        typeArguments: [],
+        arguments: []
+      });
+      return {
+        accountCap,
+        isCreate: true
+      };
+    });
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      const accountCapRes = yield this.getOrCreateAccountCap(
+        txb,
+        client.client,
+        client.signer
+      );
+      const args = [
+        txb.object(path.id),
+        inputCoin,
+        accountCapRes.accountCap,
+        txb.object(CLOCK_ADDRESS)
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::deepbook::${func}`,
+        typeArguments: [coinAType, coinBType],
+        arguments: args
+      });
+      if (accountCapRes.isCreate) {
+        txb.transferObjects([accountCapRes.accountCap], client.signer);
+      }
+      return res;
+    });
+  }
+};
+
+// src/transaction/kriya_v2.ts
+var KriyaV2 = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Kriya amm only supported on mainnet");
+    }
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      const args = [txb.object(path.id), inputCoin];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::kriya_amm::${func}`,
+        typeArguments: [coinAType, coinBType],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/flowx_v2.ts
+var FlowxV2 = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Flowx only supported on mainnet");
+    }
+    this.container = "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511";
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      const args = [txb.object(this.container), inputCoin];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::flowx_amm::${func}`,
+        typeArguments: [coinAType, coinBType],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/turbos.ts
+var Turbos = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Turbos only supported on mainnet");
+    }
+    this.versioned = "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f";
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      if (path.extendedDetails == null) {
+        throw new Error("Extended details not supported");
+      } else {
+        if (path.extendedDetails.turbosFeeType == null) {
+          throw new Error("Turbos fee type not supported");
+        }
+      }
+      const args = [
+        txb.object(path.id),
+        inputCoin,
+        txb.object(CLOCK_ADDRESS),
+        txb.object(this.versioned)
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::turbos::${func}`,
+        typeArguments: [coinAType, coinBType, path.extendedDetails.turbosFeeType],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/cetus.ts
+var Cetus = class {
+  constructor(env, partner) {
+    this.globalConfig = env === 0 /* Mainnet */ ? "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f" : "0x6f4149091a5aea0e818e7243a13adcfb403842d670b9a2089de058512620687a";
+    this.partner = partner != null ? partner : "0x639b5e433da31739e800cd085f356e64cae222966d0f1b11bd9dc76b322ff58b";
+  }
+  flash_swap(client, txb, path, by_amount_in) {
+    const { direction, from, target } = path;
+    const [func, coinAType, coinBType] = direction ? ["flash_swap_a2b", from, target] : ["flash_swap_b2a", target, from];
+    let amount = by_amount_in ? path.amountIn : path.amountOut;
+    const args = [
+      txb.object(this.globalConfig),
+      txb.object(path.id),
+      txb.object(this.partner),
+      txb.pure.u64(amount),
+      txb.pure.bool(by_amount_in),
+      txb.object(CLOCK_ADDRESS)
+    ];
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::cetus::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args
+    });
+    return {
+      targetCoin: res[0],
+      flashReceipt: res[1],
+      payAmount: res[2]
+    };
+  }
+  repay_flash_swap(client, txb, path, inputCoin, receipt) {
+    const { direction, from, target } = path;
+    const [func, coinAType, coinBType] = direction ? ["repay_flash_swap_a2b", from, target] : ["repay_flash_swap_b2a", target, from];
+    const args = [
+      txb.object(this.globalConfig),
+      txb.object(path.id),
+      txb.object(this.partner),
+      inputCoin,
+      receipt
+    ];
+    const res = txb.moveCall({
+      target: `${client.publishedAt()}::cetus::${func}`,
+      typeArguments: [coinAType, coinBType],
+      arguments: args
+    });
+    return res[0];
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      const args = [
+        txb.object(this.globalConfig),
+        txb.object(path.id),
+        txb.object(this.partner),
+        inputCoin,
+        txb.object(CLOCK_ADDRESS)
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::cetus::${func}`,
+        typeArguments: [coinAType, coinBType],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+var EQUAL = 0;
+var LESS_THAN = 1;
+var GREATER_THAN = 2;
+function cmp(a, b) {
+  if (a === b) {
+    return EQUAL;
+  }
+  if (a < b) {
+    return LESS_THAN;
+  }
+  return GREATER_THAN;
+}
+function compare(symbolX, symbolY) {
+  let i = 0;
+  const len = symbolX.length <= symbolY.length ? symbolX.length : symbolY.length;
+  const lenCmp = cmp(symbolX.length, symbolY.length);
+  while (i < len) {
+    const elemCmp = cmp(symbolX.charCodeAt(i), symbolY.charCodeAt(i));
+    i += 1;
+    if (elemCmp !== 0) {
+      return elemCmp;
+    }
+  }
+  return lenCmp;
+}
+function isSortedSymbols(symbolX, symbolY) {
+  return compare(symbolX, symbolY) === LESS_THAN;
+}
+function composeType(address, ...args) {
+  const generics = Array.isArray(args[args.length - 1]) ? args.pop() : [];
+  const chains = [address, ...args].filter(Boolean);
+  let result = chains.join("::");
+  if (generics && generics.length) {
+    result += `<${generics.join(", ")}>`;
+  }
+  return result;
+}
+function extractAddressFromType(type) {
+  return type.split("::")[0];
+}
+function extractStructTagFromType(type) {
+  var _a;
+  try {
+    let _type = type.replace(/\s/g, "");
+    const genericsString = _type.match(/(<.+>)$/);
+    const generics = (_a = genericsString == null ? void 0 : genericsString[0]) == null ? void 0 : _a.match(/(\w+::\w+::\w+)(?:<.*?>(?!>))?/g);
+    if (generics) {
+      _type = _type.slice(0, _type.indexOf("<"));
+      const tag2 = extractStructTagFromType(_type);
+      const structTag2 = __spreadProps(__spreadValues({}, tag2), {
+        type_arguments: generics.map((item) => extractStructTagFromType(item).source_address)
+      });
+      structTag2.type_arguments = structTag2.type_arguments.map((item) => {
+        return CoinUtils.isSuiCoin(item) ? item : extractStructTagFromType(item).source_address;
+      });
+      structTag2.source_address = composeType(structTag2.full_address, structTag2.type_arguments);
+      return structTag2;
+    }
+    const parts = _type.split("::");
+    const isSuiCoin = _type === GAS_TYPE_ARG || _type === GAS_TYPE_ARG_LONG;
+    const structTag = {
+      full_address: _type,
+      address: isSuiCoin ? "0x2" : utils.normalizeSuiObjectId(parts[0]),
+      module: parts[1],
+      name: parts[2],
+      type_arguments: [],
+      source_address: ""
+    };
+    structTag.full_address = `${structTag.address}::${structTag.module}::${structTag.name}`;
+    structTag.source_address = composeType(structTag.full_address, structTag.type_arguments);
+    return structTag;
+  } catch (error) {
+    return {
+      full_address: type,
+      address: "",
+      module: "",
+      name: "",
+      type_arguments: [],
+      source_address: type
+    };
+  }
+}
+function normalizeCoinType(coinType) {
+  return extractStructTagFromType(coinType).source_address;
+}
+function fixSuiObjectId(value) {
+  if (value.toLowerCase().startsWith("0x")) {
+    return utils.normalizeSuiObjectId(value);
+  }
+  return value;
+}
+function patchFixSuiObjectId(data) {
+  for (const key in data) {
+    const type = typeof data[key];
+    if (type === "object") {
+      patchFixSuiObjectId(data[key]);
+    } else if (type === "string") {
+      const value = data[key];
+      data[key] = fixSuiObjectId(value);
+    }
+  }
+}
+function createTarget(packageName, moduleName, functionName) {
+  return `${packageName}::${moduleName}::${functionName}`;
+}
+
 // src/types/CoinAssist.ts
 var COIN_TYPE = "0x2::coin::Coin";
 var COIN_TYPE_ARG_REGEX = /^0x2::coin::Coin<(.+)>$/;
@@ -5157,182 +5552,6 @@ var CoinUtils = class _CoinUtils {
   }
 };
 
-// src/utils/contracts.ts
-var EQUAL = 0;
-var LESS_THAN = 1;
-var GREATER_THAN = 2;
-function cmp(a, b) {
-  if (a === b) {
-    return EQUAL;
-  }
-  if (a < b) {
-    return LESS_THAN;
-  }
-  return GREATER_THAN;
-}
-function compare(symbolX, symbolY) {
-  let i = 0;
-  const len = symbolX.length <= symbolY.length ? symbolX.length : symbolY.length;
-  const lenCmp = cmp(symbolX.length, symbolY.length);
-  while (i < len) {
-    const elemCmp = cmp(symbolX.charCodeAt(i), symbolY.charCodeAt(i));
-    i += 1;
-    if (elemCmp !== 0) {
-      return elemCmp;
-    }
-  }
-  return lenCmp;
-}
-function isSortedSymbols(symbolX, symbolY) {
-  return compare(symbolX, symbolY) === LESS_THAN;
-}
-function composeType(address, ...args) {
-  const generics = Array.isArray(args[args.length - 1]) ? args.pop() : [];
-  const chains = [address, ...args].filter(Boolean);
-  let result = chains.join("::");
-  if (generics && generics.length) {
-    result += `<${generics.join(", ")}>`;
-  }
-  return result;
-}
-function extractAddressFromType(type) {
-  return type.split("::")[0];
-}
-function extractStructTagFromType(type) {
-  var _a;
-  try {
-    let _type = type.replace(/\s/g, "");
-    const genericsString = _type.match(/(<.+>)$/);
-    const generics = (_a = genericsString == null ? void 0 : genericsString[0]) == null ? void 0 : _a.match(/(\w+::\w+::\w+)(?:<.*?>(?!>))?/g);
-    if (generics) {
-      _type = _type.slice(0, _type.indexOf("<"));
-      const tag2 = extractStructTagFromType(_type);
-      const structTag2 = __spreadProps(__spreadValues({}, tag2), {
-        type_arguments: generics.map((item) => extractStructTagFromType(item).source_address)
-      });
-      structTag2.type_arguments = structTag2.type_arguments.map((item) => {
-        return CoinUtils.isSuiCoin(item) ? item : extractStructTagFromType(item).source_address;
-      });
-      structTag2.source_address = composeType(structTag2.full_address, structTag2.type_arguments);
-      return structTag2;
-    }
-    const parts = _type.split("::");
-    const isSuiCoin = _type === GAS_TYPE_ARG || _type === GAS_TYPE_ARG_LONG;
-    const structTag = {
-      full_address: _type,
-      address: isSuiCoin ? "0x2" : utils.normalizeSuiObjectId(parts[0]),
-      module: parts[1],
-      name: parts[2],
-      type_arguments: [],
-      source_address: ""
-    };
-    structTag.full_address = `${structTag.address}::${structTag.module}::${structTag.name}`;
-    structTag.source_address = composeType(structTag.full_address, structTag.type_arguments);
-    return structTag;
-  } catch (error) {
-    return {
-      full_address: type,
-      address: "",
-      module: "",
-      name: "",
-      type_arguments: [],
-      source_address: type
-    };
-  }
-}
-function normalizeCoinType(coinType) {
-  return extractStructTagFromType(coinType).source_address;
-}
-function fixSuiObjectId(value) {
-  if (value.toLowerCase().startsWith("0x")) {
-    return utils.normalizeSuiObjectId(value);
-  }
-  return value;
-}
-function patchFixSuiObjectId(data) {
-  for (const key in data) {
-    const type = typeof data[key];
-    if (type === "object") {
-      patchFixSuiObjectId(data[key]);
-    } else if (type === "string") {
-      const value = data[key];
-      data[key] = fixSuiObjectId(value);
-    }
-  }
-}
-function createTarget(packageName, moduleName, functionName) {
-  return `${packageName}::${moduleName}::${functionName}`;
-}
-
-// src/const.ts
-var import_bn = __toESM(require_bn());
-var CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
-var CoinInfoAddress = "0x1::coin::CoinInfo";
-var CoinStoreAddress = "0x1::coin::CoinStore";
-var SuiZeroCoinFn = "0x2::coin::zero";
-var AGGREGATOR = "aggregator";
-var CETUS_DEX = "CETUS";
-var DEEPBOOK_DEX = "DEEPBOOK";
-var KRIYA_DEX = "KRIYA";
-var FLOWX_AMM = "FLOWX";
-var TURBOS_DEX = "TURBOS";
-var AFTERMATH_AMM = "AFTERMATH";
-var INTEGRATE = "integrate";
-var CETUS_MODULE = "cetus";
-var DEEPBOOK_MODULE = "deepbook";
-var KRIYA_MODULE = "kriya";
-var UTILS_MODULE = "utils";
-var POOL_MODULT = "pool";
-var PAY_MODULE = "pay";
-var FLOWX_AMM_MODULE = "flowx_amm";
-var TURBOS_MODULE = "turbos";
-var AFTERMATH_MODULE = "aftermath";
-var DEEPBOOK_CUSTODIAN_V2_MODULE = "custodian_v2";
-var DEEPBOOK_CLOB_V2_MODULE = "clob_v2";
-var FlashSwapFunc = "flash_swap";
-var FlashSwapWithPartnerFunc = "flash_swap_with_partner";
-var RepayFalshSwapFunc = "repay_flash_swap";
-var RepayFlashSwapWithPartnerFunc = "repay_flash_swap_with_partner";
-var FlashSwapA2BFunc = "flash_swap_a2b";
-var FlashSwapB2AFunc = "flash_swap_b2a";
-var FlashSwapWithPartnerA2BFunc = "flash_swap_with_partner_a2b";
-var FlashSwapWithPartnerB2AFunc = "flash_swap_with_partner_b2a";
-var REPAY_FLASH_SWAP_A2B_FUNC = "repay_flash_swap_a2b";
-var REPAY_FLASH_SWAP_B2A_FUNC = "repay_flash_swap_b2a";
-var REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC = "repay_flash_swap_with_partner_a2b";
-var REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC = "repay_flash_swap_with_partner_b2a";
-var SWAP_A2B_FUNC = "swap_a2b";
-var SWAP_B2A_FUNC = "swap_b2a";
-var TRANSFER_OR_DESTORY_COIN_FUNC = "transfer_or_destroy_coin";
-var CHECK_COINS_THRESHOLD_FUNC = "check_coins_threshold";
-var JOIN_FUNC = "join_vec";
-var TRANSFER_ACCOUNT_CAP = "transfer_account_cap";
-var DEEPBOOK_PACKAGE_ID = "0x000000000000000000000000000000000000000000000000000000000000dee9";
-var DEEPBOOK_PUBLISHED_AT = "0x000000000000000000000000000000000000000000000000000000000000dee9";
-var CETUS_PUBLISHED_AT = "0x70968826ad1b4ba895753f634b0aea68d0672908ca1075a2abdf0fc9e0b2fc6a";
-var MAINNET_CETUS_GLOBAL_CONFIG_ID = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
-var TESTNET_CETUS_GLOBAL_CONFIG_ID = "0x6f4149091a5aea0e818e7243a13adcfb403842d670b9a2089de058512620687a";
-var ZERO = new import_bn.default(0);
-var ONE = new import_bn.default(1);
-var TWO = new import_bn.default(2);
-var U128 = TWO.pow(new import_bn.default(128));
-var U64_MAX_BN = new import_bn.default("18446744073709551615");
-var U64_MAX = "18446744073709551615";
-var TEN_POW_NINE = 1e9;
-var MAINNET_FLOWX_AMM_CONTAINER_ID = "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511";
-var TESTNET_FLOWX_AMM_CONTAINER_ID = "";
-var TURBOS_VERSIONED = "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f";
-var MAINNET_AFTERMATH_REGISTRY_ID = "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae";
-var TESTNET_AFTERMATH_REGISTRY_ID = "";
-var MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4";
-var TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = "";
-var MAINNET_AFTERMATH_TREASURY_ID = "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce";
-var TESTNET_AFTERMATH_TREASURY_ID = "";
-var MAINNET_AFTERMATH_INSURANCE_FUND_ID = "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b";
-var TESTNET_AFTERMATH_INSURANCE_FUND_ID = "";
-var MAINNET_AFTERMATH_REFERRAL_VAULT_ID = "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278";
-var TESTNET_AFTERMATH_REFERRAL_VAULT_ID = "";
-
 // src/errors.ts
 function getAggregatorServerErrorMessage(code) {
   switch (code) {
@@ -5344,980 +5563,11 @@ function getAggregatorServerErrorMessage(code) {
       return "No router";
     case 10003 /* InsufficientLiquidity */:
       return "Insufficient Liquidity";
-    default:
-      return "Unknown error";
-  }
-}
-function mintZeroCoin(txb, coinType) {
-  return txb.moveCall({
-    target: SuiZeroCoinFn,
-    typeArguments: [coinType]
-  });
-}
-function buildInputCoin(txb, allCoins, amount, coinType) {
-  const usedCoinAsests = CoinUtils.getCoinAssets(coinType, allCoins);
-  if (amount === BigInt(0) && usedCoinAsests.length === 0) {
-    const zeroCoin = mintZeroCoin(txb, coinType);
-    return {
-      targetCoin: zeroCoin,
-      isMintZeroCoin: true,
-      targetCoinAmount: 0
-    };
-  }
-  let totalCoinBalance = CoinUtils.calculateTotalBalance(usedCoinAsests);
-  if (totalCoinBalance < amount) {
-    throw new AggregateError(
-      "Insufficient balance when build merge coin",
-      "InsufficientBalance" /* InsufficientBalance */
-    );
-  }
-  if (CoinUtils.isSuiCoin(coinType)) {
-    const resultCoin = txb.splitCoins(txb.gas, [
-      txb.pure.u64(amount.toString())
-    ]);
-    return {
-      targetCoin: resultCoin,
-      isMintZeroCoin: true,
-      targetCoinAmount: Number(amount.toString())
-    };
-  }
-  let sortCoinAssets = CoinUtils.sortByBalance(usedCoinAsests);
-  let totalThreeCoinBalance = sortCoinAssets.slice(0, 3).reduce((acc, coin) => acc + coin.balance, BigInt(0));
-  if (totalThreeCoinBalance < BigInt(amount)) {
-    sortCoinAssets = CoinUtils.sortByBalanceDes(usedCoinAsests);
-  }
-  let selectedCoinResult = CoinUtils.selectCoinObjectIdGreaterThanOrEqual(
-    sortCoinAssets,
-    amount
-  );
-  const [masterCoin, ...mergedCoin] = selectedCoinResult.objectArray;
-  if (mergedCoin.length > 0) {
-    txb.mergeCoins(
-      masterCoin,
-      mergedCoin.map((coin) => txb.object(coin))
-    );
-  }
-  return {
-    targetCoin: txb.object(masterCoin),
-    isMintZeroCoin: false,
-    targetCoinAmount: Number(amount.toString())
-  };
-}
-function transferOrDestoryCoin(txb, coinObject, coinType, config2) {
-  const aggregatorPackage = config2.getPackage(AGGREGATOR);
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      "MissAggregatorPackage" /* MissAggregatorPackage */
-    );
-  }
-  const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-  txb.moveCall({
-    target: createTarget(
-      aggregatorPublishedAt,
-      UTILS_MODULE,
-      TRANSFER_OR_DESTORY_COIN_FUNC
-    ),
-    typeArguments: [coinType],
-    arguments: [coinObject]
-  });
-}
-function checkCoinThresholdAndMergeCoin(txb, coins, coinType, amountLimit, config2) {
-  const aggregatorPackage = config2.getPackage(AGGREGATOR);
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      "MissAggregatorPackage" /* MissAggregatorPackage */
-    );
-  }
-  const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-  const vec = txb.makeMoveVec({
-    elements: coins
-  });
-  txb.moveCall({
-    target: createTarget(
-      aggregatorPublishedAt,
-      UTILS_MODULE,
-      CHECK_COINS_THRESHOLD_FUNC
-    ),
-    typeArguments: [coinType],
-    arguments: [vec, txb.pure.u64(amountLimit)]
-  });
-  const zeroCoin = mintZeroCoin(txb, coinType);
-  txb.moveCall({
-    target: createTarget(utils.SUI_FRAMEWORK_ADDRESS, PAY_MODULE, JOIN_FUNC),
-    typeArguments: [coinType],
-    arguments: [zeroCoin, vec]
-  });
-  return zeroCoin;
-}
-
-// src/utils/account_cap.ts
-function getOrCreateAccountCap(txb, client, owner) {
-  return __async(this, null, function* () {
-    let accountCapStr = yield getAccountCap(client, owner);
-    if (accountCapStr !== null) {
-      return {
-        accountCap: txb.object(accountCapStr),
-        isCreate: false
-      };
-    }
-    const accountCap = txb.moveCall({
-      target: `${DEEPBOOK_PUBLISHED_AT}::${DEEPBOOK_CLOB_V2_MODULE}::create_account`,
-      typeArguments: [],
-      arguments: []
-    });
-    return {
-      accountCap,
-      isCreate: true
-    };
-  });
-}
-function getAccountCap(client, owner) {
-  return __async(this, null, function* () {
-    let limit = 50;
-    let cursor = null;
-    while (true) {
-      const ownedObjects = client.getOwnedObjects({
-        owner,
-        cursor,
-        limit,
-        filter: {
-          MoveModule: {
-            package: DEEPBOOK_PACKAGE_ID,
-            module: DEEPBOOK_CUSTODIAN_V2_MODULE
-          }
-        }
-      });
-      if (ownedObjects != null && ownedObjects.data != null) {
-        if (ownedObjects.data.length !== 0) {
-          return ownedObjects.data[0].data.objectId;
-        }
-        if (ownedObjects.data.length < 50) {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    return null;
-  });
-}
-
-// src/transaction/deepbook.ts
-function deepbookSwapMovecall(swapParams, client, txb, config2) {
-  return __async(this, null, function* () {
-    const accountCapRes = yield getOrCreateAccountCap(
-      txb,
-      client,
-      config2.getWallet()
-    );
-    const accountCap = accountCapRes.accountCap;
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    if (swapParams.a2b) {
-      if (swapParams.coinA == null) {
-        throw new AggregateError(
-          "coinA is required",
-          "MissCoinA" /* MissCoinA */
-        );
-      }
-    } else {
-      if (swapParams.coinB == null) {
-        throw new AggregateError(
-          "coinB is required",
-          "MissCoinB" /* MissCoinB */
-        );
-      }
-    }
-    const args = swapParams.a2b ? [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinA,
-      accountCap,
-      txb.pure.bool(swapParams.useFullInputCoinAmount),
-      txb.object(CLOCK_ADDRESS)
-    ] : [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinB,
-      accountCap,
-      txb.pure.bool(swapParams.useFullInputCoinAmount),
-      txb.object(CLOCK_ADDRESS)
-    ];
-    let func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC;
-    const target = createTarget(aggregatorPublishedAt, DEEPBOOK_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [swapParams.coinAType, swapParams.coinBType],
-      arguments: args
-    });
-    if (accountCapRes.isCreate) {
-      const target2 = createTarget(
-        aggregatorPublishedAt,
-        DEEPBOOK_MODULE,
-        TRANSFER_ACCOUNT_CAP
-      );
-      txb.moveCall({
-        target: target2,
-        typeArguments: [],
-        arguments: [accountCap]
-      });
-    }
-    return {
-      targetCoin: res[0],
-      amountIn: res[1],
-      amountOut: res[2],
-      txb
-    };
-  });
-}
-
-// src/transaction/kriya.ts
-function kriyaSwapMovecall(swapParams, txb, config2) {
-  return __async(this, null, function* () {
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError("Aggregator package not set", "MissAggregatorPackage" /* MissAggregatorPackage */);
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    if (swapParams.a2b) {
-      if (swapParams.coinA == null) {
-        throw new AggregateError("coinA is required", "MissCoinA" /* MissCoinA */);
-      }
-    } else {
-      if (swapParams.coinB == null) {
-        throw new AggregateError("coinB is required", "MissCoinB" /* MissCoinB */);
-      }
-    }
-    const args = swapParams.a2b ? [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinA,
-      txb.pure.bool(swapParams.useFullInputCoinAmount)
-    ] : [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinB,
-      txb.pure.bool(swapParams.useFullInputCoinAmount)
-    ];
-    const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC;
-    const target = createTarget(aggregatorPublishedAt, KRIYA_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [swapParams.coinAType, swapParams.coinBType],
-      arguments: args
-    });
-    return {
-      targetCoin: res[0],
-      amountIn: res[1],
-      amountOut: res[2],
-      txb
-    };
-  });
-}
-
-// src/config.ts
-var ENV = /* @__PURE__ */ ((ENV2) => {
-  ENV2[ENV2["MAINNET"] = 0] = "MAINNET";
-  ENV2[ENV2["TESTNET"] = 1] = "TESTNET";
-  return ENV2;
-})(ENV || {});
-var AggregatorConfig = class {
-  constructor(aggregatorUrl, fullNodeUrl, wallet, packages, env) {
-    this.aggregatorUrl = aggregatorUrl;
-    this.fullNodeUrl = fullNodeUrl;
-    this.wallet = wallet;
-    this.packages = packages;
-    this.env = env;
-  }
-  getAggregatorUrl() {
-    return this.aggregatorUrl;
-  }
-  getFullNodeUrl() {
-    return this.fullNodeUrl;
-  }
-  getWallet() {
-    return this.wallet;
-  }
-  getENV() {
-    return this.env;
-  }
-  getPackages() {
-    return this.packages;
-  }
-  getPackage(packageName) {
-    return this.packages.find((pkg) => pkg.packageName === packageName);
-  }
-  addPackage(newPackage) {
-    if (!newPackage.packageName || !newPackage.packageId || !newPackage.publishedAt) {
-      throw new Error("Invalid package data");
-    }
-    this.packages.push(newPackage);
-  }
-  removePackageById(packageId) {
-    this.packages = this.packages.filter((pkg) => pkg.packageId !== packageId);
-  }
-  findPackageById(packageId) {
-    return this.packages.find((pkg) => pkg.packageId === packageId);
-  }
-};
-
-// src/transaction/cetus.ts
-function cetusFlashSwapMovecall(swapParams, txb, config2) {
-  const aggregatorPackage = config2.getPackage(AGGREGATOR);
-  if (aggregatorPackage == null) {
-    throw new AggregateError(
-      "Aggregator package not set",
-      "MissAggregatorPackage" /* MissAggregatorPackage */
-    );
-  }
-  const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-  const globalConfigId = config2.getENV() === 0 /* MAINNET */ ? MAINNET_CETUS_GLOBAL_CONFIG_ID : TESTNET_CETUS_GLOBAL_CONFIG_ID;
-  const hasPartner = swapParams.partner != null && swapParams.partner.length > 0;
-  const args = hasPartner ? [
-    txb.object(globalConfigId),
-    txb.object(swapParams.poolId),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    txb.pure.bool(swapParams.byAmountIn),
-    txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
-    txb.object(swapParams.partner.toString()),
-    txb.object(CLOCK_ADDRESS)
-  ] : [
-    txb.object(globalConfigId),
-    txb.object(swapParams.poolId),
-    swapParams.amount,
-    txb.pure.u64(swapParams.amountLimit),
-    txb.pure.bool(swapParams.byAmountIn),
-    txb.pure.u128(swapParams.sqrtPriceLimit.toString()),
-    txb.object(CLOCK_ADDRESS)
-  ];
-  let func;
-  if (hasPartner) {
-    if (swapParams.a2b) {
-      func = FlashSwapWithPartnerA2BFunc;
-    } else {
-      func = FlashSwapWithPartnerB2AFunc;
-    }
-  } else {
-    if (swapParams.a2b) {
-      func = FlashSwapA2BFunc;
-    } else {
-      func = FlashSwapB2AFunc;
-    }
-  }
-  const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func);
-  const moveCallRes = txb.moveCall({
-    target,
-    typeArguments: [swapParams.coinAType, swapParams.coinBType],
-    arguments: args
-  });
-  return {
-    targetCoin: moveCallRes[0],
-    flashReceipt: moveCallRes[1],
-    payAmount: moveCallRes[2],
-    swapedAmount: moveCallRes[3],
-    txb
-  };
-}
-function cetusRepayFlashSwapMovecall(repayParams, txb, config2) {
-  return __async(this, null, function* () {
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    const globalConfigId = config2.getENV() === 0 /* MAINNET */ ? MAINNET_CETUS_GLOBAL_CONFIG_ID : TESTNET_CETUS_GLOBAL_CONFIG_ID;
-    const hasPartner = repayParams.partner != null && repayParams.partner.length > 0;
-    if (repayParams.a2b) {
-      if (repayParams.coinA == null) {
-        throw new AggregateError(
-          "coinA is required",
-          "MissCoinA" /* MissCoinA */
-        );
-      }
-    } else {
-      if (repayParams.coinB == null) {
-        throw new AggregateError(
-          "coinB is required",
-          "MissCoinB" /* MissCoinB */
-        );
-      }
-    }
-    let args;
-    if (hasPartner) {
-      if (repayParams.a2b) {
-        args = [
-          txb.object(globalConfigId),
-          txb.object(repayParams.poolId),
-          repayParams.coinA,
-          repayParams.receipt,
-          txb.object(repayParams.partner)
-        ];
-      } else {
-        args = [
-          txb.object(globalConfigId),
-          txb.object(repayParams.poolId),
-          repayParams.coinB,
-          repayParams.receipt,
-          txb.object(repayParams.partner)
-        ];
-      }
-    } else {
-      if (repayParams.a2b) {
-        args = [
-          txb.object(globalConfigId),
-          txb.object(repayParams.poolId),
-          repayParams.coinA,
-          repayParams.receipt
-        ];
-      } else {
-        args = [
-          txb.object(globalConfigId),
-          txb.object(repayParams.poolId),
-          repayParams.coinB,
-          repayParams.receipt
-        ];
-      }
-    }
-    let func;
-    if (hasPartner) {
-      if (repayParams.a2b) {
-        func = REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC;
-      } else {
-        func = REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC;
-      }
-    } else {
-      if (repayParams.a2b) {
-        func = REPAY_FLASH_SWAP_A2B_FUNC;
-      } else {
-        func = REPAY_FLASH_SWAP_B2A_FUNC;
-      }
-    }
-    const target = createTarget(aggregatorPublishedAt, CETUS_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [repayParams.coinAType, repayParams.coinBType],
-      arguments: args
-    });
-    return {
-      repayTargetCoin: res[0]
-    };
-  });
-}
-function cetusSwapWithOutLimit(swapParams, fromCoin, txb, config2) {
-  return __async(this, null, function* () {
-    const flashResult = cetusFlashSwapMovecall(swapParams, txb, config2);
-    const repayCoinA = swapParams.a2b ? fromCoin : void 0;
-    const repayCoinB = swapParams.a2b ? void 0 : fromCoin;
-    const repayParams = {
-      poolId: swapParams.poolId,
-      a2b: swapParams.a2b,
-      coinA: repayCoinA,
-      coinB: repayCoinB,
-      receipt: flashResult.flashReceipt,
-      coinAType: swapParams.coinAType,
-      coinBType: swapParams.coinBType,
-      partner: swapParams.partner
-    };
-    let nextInputAmount;
-    if (swapParams.byAmountIn) {
-      nextInputAmount = flashResult.swapedAmount;
-    } else {
-      nextInputAmount = flashResult.payAmount;
-    }
-    const repayResult = yield cetusRepayFlashSwapMovecall(
-      repayParams,
-      txb,
-      config2
-    );
-    return {
-      flashTargetCoin: flashResult.targetCoin,
-      repayTargetCoin: repayResult.repayTargetCoin,
-      nextInputAmount
-    };
-  });
-}
-
-// src/math.ts
-var import_bn2 = __toESM(require_bn());
-function CalculateAmountLimit(expectAmount, byAmountIn, slippage) {
-  let amountLimit = ZERO;
-  if (byAmountIn) {
-    amountLimit = expectAmount.mul(new import_bn2.default(TEN_POW_NINE - slippage * TEN_POW_NINE)).div(new import_bn2.default(TEN_POW_NINE));
-  } else {
-    amountLimit = expectAmount.mul(new import_bn2.default(TEN_POW_NINE + slippage * TEN_POW_NINE)).div(new import_bn2.default(TEN_POW_NINE));
-  }
-  return Number(amountLimit.toString());
-}
-var MAX_SQER_PRICE_X64 = "79226673515401279992447579055";
-var MIN_SQER_PRICE_X64 = "4295048016";
-function GetDefaultSqrtPriceLimit(a2b) {
-  if (a2b) {
-    return new import_bn2.default(MIN_SQER_PRICE_X64);
-  } else {
-    return new import_bn2.default(MAX_SQER_PRICE_X64);
-  }
-}
-function sqrtPriceX64ToPrice(sqrtPriceStr, decimalsA, decimalsB) {
-  const sqrtPriceX64 = new decimal_default(sqrtPriceStr).mul(decimal_default.pow(2, -64));
-  return sqrtPriceX64.pow(2).mul(decimal_default.pow(10, decimalsA - decimalsB));
-}
-
-// src/transaction/flowx.ts
-function flowxAmmSwapMovecall(swapParams, txb, config2) {
-  return __async(this, null, function* () {
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    if (swapParams.a2b) {
-      if (swapParams.coinA == null) {
-        throw new AggregateError(
-          "coinA is required",
-          "MissCoinA" /* MissCoinA */
-        );
-      }
-    } else {
-      if (swapParams.coinB == null) {
-        throw new AggregateError(
-          "coinB is required",
-          "MissCoinB" /* MissCoinB */
-        );
-      }
-    }
-    const containerID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_FLOWX_AMM_CONTAINER_ID : TESTNET_FLOWX_AMM_CONTAINER_ID;
-    const swapCoin = swapParams.a2b ? swapParams.coinA : swapParams.coinB;
-    const args = [
-      txb.object(containerID),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapCoin,
-      txb.pure.bool(swapParams.useFullInputCoinAmount)
-    ];
-    const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC;
-    const target = createTarget(aggregatorPublishedAt, FLOWX_AMM_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [swapParams.coinAType, swapParams.coinBType],
-      arguments: args
-    });
-    return {
-      targetCoin: res[0],
-      amountIn: res[1],
-      amountOut: res[2],
-      txb
-    };
-  });
-}
-
-// src/transaction/turbos.ts
-function turbosClmmSwapMovecall(swapParams, txb, config2) {
-  return __async(this, null, function* () {
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    if (swapParams.a2b) {
-      if (swapParams.coinA == null) {
-        throw new AggregateError(
-          "coinA is required",
-          "MissCoinA" /* MissCoinA */
-        );
-      }
-    } else {
-      if (swapParams.coinB == null) {
-        throw new AggregateError(
-          "coinB is required",
-          "MissCoinB" /* MissCoinB */
-        );
-      }
-    }
-    const sqrtPriceLimit = swapParams.a2b ? "4295048016" : "79226673515401279992447579055";
-    const args = swapParams.a2b ? [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinA,
-      txb.pure.bool(swapParams.useFullInputCoinAmount),
-      txb.pure.u128(sqrtPriceLimit),
-      txb.object(CLOCK_ADDRESS),
-      txb.object(TURBOS_VERSIONED)
-    ] : [
-      txb.object(swapParams.poolId),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      swapParams.coinB,
-      txb.pure.bool(swapParams.useFullInputCoinAmount),
-      txb.pure.u128(sqrtPriceLimit),
-      txb.object(CLOCK_ADDRESS),
-      txb.object(TURBOS_VERSIONED)
-    ];
-    const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC;
-    const target = createTarget(aggregatorPublishedAt, TURBOS_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [
-        swapParams.coinAType,
-        swapParams.coinBType,
-        swapParams.feeType
-      ],
-      arguments: args
-    });
-    return {
-      targetCoin: res[0],
-      amountIn: res[1],
-      amountOut: res[2],
-      txb
-    };
-  });
-}
-
-// src/transaction/aftermath.ts
-function AftermathAmmSwapMovecall(swapParams, txb, config2) {
-  return __async(this, null, function* () {
-    const aggregatorPackage = config2.getPackage(AGGREGATOR);
-    if (aggregatorPackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const aggregatorPublishedAt = aggregatorPackage.publishedAt;
-    if (swapParams.a2b) {
-      if (swapParams.coinA == null) {
-        throw new AggregateError(
-          "coinA is required",
-          "MissCoinA" /* MissCoinA */
-        );
-      }
-    } else {
-      if (swapParams.coinB == null) {
-        throw new AggregateError(
-          "coinB is required",
-          "MissCoinB" /* MissCoinB */
-        );
-      }
-    }
-    const poolRegistryID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_AFTERMATH_REGISTRY_ID : TESTNET_AFTERMATH_REGISTRY_ID;
-    const vaultID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID : TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID;
-    const treasuryID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_AFTERMATH_TREASURY_ID : TESTNET_AFTERMATH_TREASURY_ID;
-    const insuranceFundID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_AFTERMATH_INSURANCE_FUND_ID : TESTNET_AFTERMATH_INSURANCE_FUND_ID;
-    const referrealVaultID = config2.getENV() === 0 /* MAINNET */ ? MAINNET_AFTERMATH_REFERRAL_VAULT_ID : TESTNET_AFTERMATH_REFERRAL_VAULT_ID;
-    const swapCoin = swapParams.a2b ? swapParams.coinA : swapParams.coinB;
-    const slippageArg = (1 - swapParams.slippage) * 1e18;
-    const args = [
-      txb.object(swapParams.poolId),
-      txb.object(poolRegistryID),
-      txb.object(vaultID),
-      txb.object(treasuryID),
-      txb.object(insuranceFundID),
-      txb.object(referrealVaultID),
-      swapParams.amount,
-      txb.pure.u64(swapParams.amountLimit),
-      txb.pure.u64(swapParams.amountOut),
-      txb.pure.u64(slippageArg),
-      swapCoin,
-      txb.pure.bool(swapParams.useFullInputCoinAmount)
-    ];
-    const func = swapParams.a2b ? SWAP_A2B_FUNC : SWAP_B2A_FUNC;
-    const target = createTarget(aggregatorPublishedAt, AFTERMATH_MODULE, func);
-    const res = txb.moveCall({
-      target,
-      typeArguments: [
-        swapParams.coinAType,
-        swapParams.coinBType,
-        swapParams.lpSupplyType
-      ],
-      arguments: args
-    });
-    return {
-      targetCoin: res[0],
-      amountIn: res[1],
-      amountOut: res[2],
-      txb
-    };
-  });
-}
-
-// src/transaction/router.ts
-function expectInputRouterSwap(client, params, txb, fromCoin, config2, partner) {
-  return __async(this, null, function* () {
-    const splitAmounts = params.routers.map(
-      (router) => router.amountIn.toString()
-    );
-    const targetCoins = [];
-    const fromCoins = txb.splitCoins(fromCoin, splitAmounts);
-    for (let i = 0; i < params.routers.length; i++) {
-      const router = params.routers[i];
-      let intermediateTargetCoin;
-      let nextFromCoin = fromCoins[i];
-      let nextFlashAmount = txb.pure.u64(splitAmounts[i]);
-      for (let j = 0; j < router.path.length; j++) {
-        const firstPathPool = j === 0;
-        const path = router.path[j];
-        if (path.provider === CETUS_DEX) {
-          const swapParams = {
-            poolId: path.id,
-            amount: nextFlashAmount,
-            amountLimit: "0",
-            a2b: path.a2b,
-            byAmountIn: true,
-            sqrtPriceLimit: GetDefaultSqrtPriceLimit(path.a2b),
-            partner,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? path.target : path.from
-          };
-          const swapResult = yield cetusSwapWithOutLimit(
-            swapParams,
-            nextFromCoin,
-            txb,
-            config2
-          );
-          transferOrDestoryCoin(
-            txb,
-            swapResult.repayTargetCoin,
-            path.from,
-            config2
-          );
-          intermediateTargetCoin = swapResult.flashTargetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = swapResult.nextInputAmount;
-        }
-        if (path.provider === DEEPBOOK_DEX) {
-          const coinA = path.a2b ? nextFromCoin : void 0;
-          const coinB = path.a2b ? void 0 : nextFromCoin;
-          const swapParams = {
-            poolId: path.id,
-            a2b: path.a2b,
-            amount: nextFlashAmount,
-            amountLimit: 0,
-            coinA,
-            coinB,
-            useFullInputCoinAmount: !firstPathPool,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? params.targetCoinType : path.from
-          };
-          const deepbookSwapResult = yield deepbookSwapMovecall(
-            swapParams,
-            client,
-            txb,
-            config2
-          );
-          intermediateTargetCoin = deepbookSwapResult.targetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = deepbookSwapResult.amountOut;
-        }
-        if (path.provider === KRIYA_DEX) {
-          const coinA = path.a2b ? nextFromCoin : void 0;
-          const coinB = path.a2b ? void 0 : nextFromCoin;
-          const swapParams = {
-            poolId: path.id,
-            amount: nextFlashAmount,
-            amountLimit: 0,
-            a2b: path.a2b,
-            byAmountIn: true,
-            coinA,
-            coinB,
-            useFullInputCoinAmount: !firstPathPool,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? path.target : path.from
-          };
-          const swapResult = yield kriyaSwapMovecall(swapParams, txb, config2);
-          intermediateTargetCoin = swapResult.targetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = swapResult.amountOut;
-        }
-        if (path.provider === FLOWX_AMM) {
-          const coinA = path.a2b ? nextFromCoin : void 0;
-          const coinB = path.a2b ? void 0 : nextFromCoin;
-          const swapParams = {
-            amount: nextFlashAmount,
-            amountLimit: 0,
-            a2b: path.a2b,
-            byAmountIn: true,
-            coinA,
-            coinB,
-            useFullInputCoinAmount: !firstPathPool,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? path.target : path.from
-          };
-          const swapResult = yield flowxAmmSwapMovecall(swapParams, txb, config2);
-          intermediateTargetCoin = swapResult.targetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = swapResult.amountOut;
-        }
-        if (path.provider === TURBOS_DEX) {
-          const coinA = path.a2b ? nextFromCoin : void 0;
-          const coinB = path.a2b ? void 0 : nextFromCoin;
-          let feeType = "";
-          if (path.extendedDetails != null && path.extendedDetails.turbosFeeType != null) {
-            feeType = path.extendedDetails.turbosFeeType;
-          } else {
-            throw new AggregateError(
-              "Build turbos swap movecall error: ",
-              "MissTurbosFeeType" /* MissTurbosFeeType */
-            );
-          }
-          const swapParams = {
-            poolId: path.id,
-            amount: nextFlashAmount,
-            amountLimit: 0,
-            a2b: path.a2b,
-            byAmountIn: true,
-            coinA,
-            coinB,
-            useFullInputCoinAmount: !firstPathPool,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? path.target : path.from,
-            feeType
-          };
-          const swapResult = yield turbosClmmSwapMovecall(swapParams, txb, config2);
-          intermediateTargetCoin = swapResult.targetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = swapResult.amountOut;
-        }
-        if (path.provider === AFTERMATH_AMM) {
-          const coinA = path.a2b ? nextFromCoin : void 0;
-          const coinB = path.a2b ? void 0 : nextFromCoin;
-          let lpSupplyType = "";
-          if (path.extendedDetails != null && path.extendedDetails.aftermathLpSupplyType != null) {
-            lpSupplyType = path.extendedDetails.aftermathLpSupplyType;
-          } else {
-            throw new AggregateError(
-              "Build aftermath swap movecall error: ",
-              "MissAftermathLpSupplyType" /* MissAftermathLpSupplyType */
-            );
-          }
-          const swapParams = {
-            poolId: path.id,
-            amount: nextFlashAmount,
-            amountOut: path.amountOut,
-            amountLimit: 0,
-            a2b: path.a2b,
-            byAmountIn: true,
-            coinA,
-            coinB,
-            useFullInputCoinAmount: !firstPathPool,
-            coinAType: path.a2b ? path.from : path.target,
-            coinBType: path.a2b ? path.target : path.from,
-            slippage: params.slippage,
-            lpSupplyType
-          };
-          const swapResult = yield AftermathAmmSwapMovecall(
-            swapParams,
-            txb,
-            config2
-          );
-          intermediateTargetCoin = swapResult.targetCoin;
-          nextFromCoin = intermediateTargetCoin;
-          nextFlashAmount = swapResult.amountOut;
-        }
-      }
-      targetCoins.push(nextFromCoin);
-    }
-    transferOrDestoryCoin(txb, fromCoin, params.fromCoinType, config2);
-    return targetCoins;
-  });
-}
-function expectOutputRouterSwap(params, txb, fromCoin, config2, partner) {
-  return __async(this, null, function* () {
-    const splitAmounts = params.routers.map(
-      (router) => router.amountOut.toString()
-    );
-    const returnCoins = [];
-    const receipts = [];
-    const targetCoins = [];
-    for (let i = 0; i < params.routers.length; i++) {
-      const router = params.routers[i];
-      let nextFlashAmount = txb.pure.u64(splitAmounts[i]);
-      for (let j = router.path.length - 1; j >= 0; j--) {
-        const path = router.path[j];
-        const coinAType = path.a2b ? path.from : path.target;
-        const coinBType = path.a2b ? path.target : path.from;
-        const swapParams = {
-          poolId: path.id,
-          amount: nextFlashAmount,
-          amountLimit: U64_MAX,
-          a2b: path.a2b,
-          byAmountIn: false,
-          sqrtPriceLimit: GetDefaultSqrtPriceLimit(path.a2b),
-          //
-          partner,
-          coinAType,
-          coinBType
-        };
-        const flashSwapResult = cetusFlashSwapMovecall(swapParams, txb, config2);
-        nextFlashAmount = flashSwapResult.payAmount;
-        returnCoins.unshift(flashSwapResult.targetCoin);
-        receipts.unshift(flashSwapResult.flashReceipt);
-      }
-      let nextRepayCoin = fromCoin;
-      for (let j = 0; j < router.path.length; j++) {
-        const path = router.path[j];
-        const coinAType = path.a2b ? path.from : path.target;
-        const coinBType = path.a2b ? path.target : path.from;
-        const repayParams = {
-          poolId: path.id,
-          a2b: path.a2b,
-          partner,
-          coinA: path.a2b ? nextRepayCoin : void 0,
-          coinB: path.a2b ? void 0 : nextRepayCoin,
-          receipt: receipts[j],
-          coinAType,
-          coinBType
-        };
-        const repayResult = yield cetusRepayFlashSwapMovecall(
-          repayParams,
-          txb,
-          config2
-        );
-        nextRepayCoin = returnCoins[j];
-        if (j === 0) {
-          fromCoin = repayResult.repayTargetCoin;
-        } else {
-          transferOrDestoryCoin(
-            txb,
-            repayResult.repayTargetCoin,
-            path.from,
-            config2
-          );
-        }
-        if (j === router.path.length - 1) {
-          targetCoins.push(nextRepayCoin);
-        }
-      }
-    }
-    transferOrDestoryCoin(txb, fromCoin, params.fromCoinType, config2);
-    return targetCoins;
-  });
+    default:
+      return "Unknown error";
+  }
 }
 
-// src/client.ts
-var import_bn4 = __toESM(require_bn());
-
 // src/utils/coin.ts
 function completionCoin(s) {
   const index = s.indexOf("::");
@@ -6349,6 +5599,61 @@ function compareCoins(coinA, coinB) {
   }
   return true;
 }
+function mintZeroCoin(txb, coinType) {
+  return txb.moveCall({
+    target: "0x2::coin::zero",
+    typeArguments: [coinType]
+  });
+}
+function buildInputCoin(txb, allCoins, amount, coinType) {
+  const usedCoinAsests = CoinUtils.getCoinAssets(coinType, allCoins);
+  if (amount === BigInt(0) && usedCoinAsests.length === 0) {
+    const zeroCoin = mintZeroCoin(txb, coinType);
+    return {
+      targetCoin: zeroCoin,
+      isMintZeroCoin: true,
+      targetCoinAmount: 0
+    };
+  }
+  let totalCoinBalance = CoinUtils.calculateTotalBalance(usedCoinAsests);
+  if (totalCoinBalance < amount) {
+    throw new AggregateError(
+      "Insufficient balance when build merge coin",
+      "InsufficientBalance" /* InsufficientBalance */
+    );
+  }
+  if (CoinUtils.isSuiCoin(coinType)) {
+    const resultCoin = txb.splitCoins(txb.gas, [
+      txb.pure.u64(amount.toString())
+    ]);
+    return {
+      targetCoin: resultCoin,
+      isMintZeroCoin: true,
+      targetCoinAmount: Number(amount.toString())
+    };
+  }
+  let sortCoinAssets = CoinUtils.sortByBalance(usedCoinAsests);
+  let totalThreeCoinBalance = sortCoinAssets.slice(0, 3).reduce((acc, coin) => acc + coin.balance, BigInt(0));
+  if (totalThreeCoinBalance < BigInt(amount)) {
+    sortCoinAssets = CoinUtils.sortByBalanceDes(usedCoinAsests);
+  }
+  let selectedCoinResult = CoinUtils.selectCoinObjectIdGreaterThanOrEqual(
+    sortCoinAssets,
+    amount
+  );
+  const [masterCoin, ...mergedCoin] = selectedCoinResult.objectArray;
+  if (mergedCoin.length > 0) {
+    txb.mergeCoins(
+      masterCoin,
+      mergedCoin.map((coin) => txb.object(coin))
+    );
+  }
+  return {
+    targetCoin: txb.object(masterCoin),
+    isMintZeroCoin: false,
+    targetCoinAmount: Number(amount.toString())
+  };
+}
 
 // src/utils/transaction.ts
 function checkInvalidSuiAddress(address) {
@@ -6359,30 +5664,53 @@ function checkInvalidSuiAddress(address) {
 }
 
 // src/transaction/swap.ts
+var import_bn4 = __toESM(require_bn());
+
+// src/math.ts
 var import_bn3 = __toESM(require_bn());
-function swapInPools(client, params, config2) {
+
+// src/const.ts
+var import_bn2 = __toESM(require_bn());
+var ZERO = new import_bn2.default(0);
+var ONE = new import_bn2.default(1);
+var TWO = new import_bn2.default(2);
+var U128 = TWO.pow(new import_bn2.default(128));
+var U64_MAX_BN = new import_bn2.default("18446744073709551615");
+var U64_MAX = "18446744073709551615";
+var TEN_POW_NINE = 1e9;
+
+// src/math.ts
+function CalculateAmountLimit(expectAmount, byAmountIn, slippage) {
+  let amountLimit = ZERO;
+  if (byAmountIn) {
+    amountLimit = expectAmount.mul(new import_bn3.default(TEN_POW_NINE - slippage * TEN_POW_NINE)).div(new import_bn3.default(TEN_POW_NINE));
+  } else {
+    amountLimit = expectAmount.mul(new import_bn3.default(TEN_POW_NINE + slippage * TEN_POW_NINE)).div(new import_bn3.default(TEN_POW_NINE));
+  }
+  return Number(amountLimit.toString());
+}
+function sqrtPriceX64ToPrice(sqrtPriceStr, decimalsA, decimalsB) {
+  const sqrtPriceX64 = new decimal_default(sqrtPriceStr).mul(decimal_default.pow(2, -64));
+  return sqrtPriceX64.pow(2).mul(decimal_default.pow(10, decimalsA - decimalsB));
+}
+
+// src/transaction/swap.ts
+function swapInPools(client, params, sender) {
   return __async(this, null, function* () {
     var _a, _b, _c, _d, _e;
     const { from, target, amount, byAmountIn, pools } = params;
     const fromCoin = completionCoin(from);
     const targetCoin = completionCoin(target);
     const tx = new transactions.Transaction();
-    const a2b = compareCoins(fromCoin, targetCoin);
-    const integratePackage = config2.getPackage(INTEGRATE);
-    if (integratePackage == null) {
-      throw new AggregateError(
-        "Aggregator package not set",
-        "MissAggregatorPackage" /* MissAggregatorPackage */
-      );
-    }
-    const integratePublishedAt = integratePackage.publishedAt;
-    const coinA = a2b ? fromCoin : targetCoin;
-    const coinB = a2b ? targetCoin : fromCoin;
+    const direction = compareCoins(fromCoin, targetCoin);
+    const integratePublishedAt = "0x8faab90228e4c4df91c41626bbaefa19fc25c514405ac64de54578dec9e6f5ee";
+    const coinA = direction ? fromCoin : targetCoin;
+    const coinB = direction ? targetCoin : fromCoin;
     const typeArguments = [coinA, coinB];
     for (let i = 0; i < pools.length; i++) {
       const args = [
         tx.object(pools[i]),
-        tx.pure.bool(a2b),
+        tx.pure.bool(direction),
         tx.pure.bool(byAmountIn),
         tx.pure.u64(amount.toString())
       ];
@@ -6392,7 +5720,7 @@ function swapInPools(client, params, config2) {
         typeArguments
       });
     }
-    if (!checkInvalidSuiAddress(config2.getWallet())) {
+    if (!checkInvalidSuiAddress(sender)) {
       throw new AggregateError(
         "Aggregator package not set",
         "InvalidWallet" /* InvalidWallet */
@@ -6400,7 +5728,7 @@ function swapInPools(client, params, config2) {
     }
     const simulateRes = yield client.devInspectTransactionBlock({
       transactionBlock: tx,
-      sender: config2.getWallet()
+      sender
     });
     if (simulateRes.error != null) {
       throw new AggregateError(
@@ -6424,13 +5752,13 @@ function swapInPools(client, params, config2) {
         continue;
       }
       if (params.byAmountIn) {
-        const amount2 = new import_bn3.BN(valueData[i].parsedJson.data.amount_out);
+        const amount2 = new import_bn4.BN(valueData[i].parsedJson.data.amount_out);
         if (amount2.gt(tempMaxAmount)) {
           tempIndex = i;
           tempMaxAmount = amount2;
         }
       } else {
-        const amount2 = new import_bn3.BN(valueData[i].parsedJson.data.amount_out);
+        const amount2 = new import_bn4.BN(valueData[i].parsedJson.data.amount_out);
         if (amount2.lt(tempMaxAmount)) {
           tempIndex = i;
           tempMaxAmount = amount2;
@@ -6438,6 +5766,7 @@ function swapInPools(client, params, config2) {
       }
     }
     const event = valueData[tempIndex].parsedJson.data;
+    console.log("event", JSON.stringify(event, null, 2));
     const currentSqrtPrice = event.step_results[0].current_sqrt_price;
     const [decimalA, decimalB] = yield Promise.all([
       client.getCoinMetadata({ coinType: coinA }).then((metadata) => metadata == null ? void 0 : metadata.decimals),
@@ -6455,24 +5784,24 @@ function swapInPools(client, params, config2) {
       decimalB
     );
     const routeData = {
-      amountIn: new import_bn3.BN((_b = event.amount_in) != null ? _b : 0),
-      amountOut: new import_bn3.BN((_c = event.amount_out) != null ? _c : 0),
+      amountIn: new import_bn4.BN((_b = event.amount_in) != null ? _b : 0),
+      amountOut: new import_bn4.BN((_c = event.amount_out) != null ? _c : 0),
       routes: [
         {
           path: [
             {
               id: pools[tempIndex],
-              a2b,
-              provider: CETUS_DEX,
+              direction,
+              provider: "CETUS",
               from: fromCoin,
               target: targetCoin,
-              feeRate: 0,
-              amountIn: 0,
-              amountOut: 0
+              feeRate: event.fee_rate,
+              amountIn: event.amount_in,
+              amountOut: event.amount_out
             }
           ],
-          amountIn: new import_bn3.BN((_d = event.amount_in) != null ? _d : 0),
-          amountOut: new import_bn3.BN((_e = event.amount_out) != null ? _e : 0),
+          amountIn: new import_bn4.BN((_d = event.amount_in) != null ? _d : 0),
+          amountOut: new import_bn4.BN((_e = event.amount_out) != null ? _e : 0),
           initialPrice
         }
       ],
@@ -6485,11 +5814,146 @@ function swapInPools(client, params, config2) {
     return result;
   });
 }
-var AggregatorClient = class {
-  constructor(config2) {
-    this.config = config2;
-    this.client = new client.SuiClient({ url: config2.getFullNodeUrl() });
-    this.wallet = config2.getWallet();
+
+// src/transaction/kriya_v3.ts
+var KriyaV3 = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Kriya clmm only supported on mainnet");
+    }
+    this.version = "0xf5145a7ac345ca8736cf8c76047d00d6d378f30e81be6f6eb557184d9de93c78";
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction, from, target } = path;
+      const [func, coinAType, coinBType] = direction ? ["swap_a2b", from, target] : ["swap_b2a", target, from];
+      const args = [
+        txb.object(path.id),
+        inputCoin,
+        txb.object(this.version),
+        txb.object(CLOCK_ADDRESS)
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::kriya_clmm::${func}`,
+        typeArguments: [coinAType, coinBType],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/haedal.ts
+var Haedal = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Haedal only supported on mainnet");
+    }
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction } = path;
+      if (!direction) {
+        throw new Error("Haedal not support b2a swap");
+      }
+      const func = "swap_a2b";
+      console.log("haedal path id", path.id);
+      const args = [txb.object(path.id), txb.object("0x5"), inputCoin];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::haedal::${func}`,
+        typeArguments: [],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/afsui.ts
+var Afsui = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Afsui only supported on mainnet");
+    }
+    this.stakedSuiVault = "0x2f8f6d5da7f13ea37daa397724280483ed062769813b6f31e9788e59cc88994d";
+    this.safe = "0xeb685899830dd5837b47007809c76d91a098d52aabbf61e8ac467c59e5cc4610";
+    this.referVault = "0x4ce9a19b594599536c53edb25d22532f82f18038dc8ef618afd00fbbfb9845ef";
+    this.validator = "0xd30018ec3f5ff1a3c75656abf927a87d7f0529e6dc89c7ddd1bd27ecb05e3db2";
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction } = path;
+      if (!direction) {
+        throw new Error("Afsui not support b2a swap");
+      }
+      const func = "swap_a2b";
+      const args = [
+        txb.object(this.stakedSuiVault),
+        txb.object(this.safe),
+        txb.object("0x5"),
+        txb.object(this.referVault),
+        txb.object(this.validator),
+        inputCoin
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::afsui::${func}`,
+        typeArguments: [],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/transaction/volo.ts
+var Volo = class {
+  constructor(env) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("Volo only supported on mainnet");
+    }
+    this.nativePool = "0x7fa2faa111b8c65bea48a23049bfd81ca8f971a262d981dcd9a17c3825cb5baf";
+    this.metadata = "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60";
+  }
+  swap(client, txb, path, inputCoin) {
+    return __async(this, null, function* () {
+      const { direction } = path;
+      if (!direction) {
+        throw new Error("Volo not support b2a swap");
+      }
+      const func = "swap_a2b";
+      const args = [
+        txb.object(this.nativePool),
+        txb.object(this.metadata),
+        txb.object("0x5"),
+        inputCoin
+      ];
+      const res = txb.moveCall({
+        target: `${client.publishedAt()}::volo::${func}`,
+        typeArguments: [],
+        arguments: args
+      });
+      return res;
+    });
+  }
+};
+
+// src/client.ts
+var CETUS = "CETUS";
+var DEEPBOOKV2 = "DEEPBOOK";
+var KRIYA = "KRIYA";
+var FLOWXV2 = "FLOWX";
+var KRIYAV3 = "KRIYAV3";
+var TURBOS = "TURBOS";
+var AFTERMATH = "AFTERMATH";
+var HAEDAL = "HAEDAL";
+var VOLO = "VOLO";
+var AFSUI = "AFSUI";
+var AggregatorClient5 = class {
+  constructor(endpoint, signer, client, env) {
+    this.endpoint = endpoint;
+    this.client = client;
+    this.signer = signer;
+    this.env = env;
     this.allCoins = [];
   }
   getAllCoins() {
@@ -6499,7 +5963,7 @@ var AggregatorClient = class {
       const allCoins = [];
       while (true) {
         const gotAllCoins = yield this.client.getAllCoins({
-          owner: this.wallet,
+          owner: this.signer,
           cursor,
           limit
         });
@@ -6518,79 +5982,95 @@ var AggregatorClient = class {
       return allCoins;
     });
   }
-  findRouter(fromRouterParams) {
+  findRouters(params) {
     return __async(this, null, function* () {
-      const {
-        from,
-        target,
-        amount,
-        byAmountIn,
-        depth,
-        splitAlgorithm,
-        splitFactor,
-        splitCount,
-        providers
-      } = fromRouterParams;
-      const fromCoin = completionCoin(from);
-      const targetCoin = completionCoin(target);
-      let url = this.config.getAggregatorUrl() + `/find_routes?from=${fromCoin}&target=${targetCoin}&amount=${amount.toString()}&by_amount_in=${byAmountIn}`;
-      if (depth) {
-        url += `&depth=${depth}`;
-      }
-      if (splitAlgorithm) {
-        url += `&split_algorithm=${splitAlgorithm}`;
-      }
-      if (splitFactor) {
-        url += `&split_factor=${splitFactor}`;
-      }
-      if (splitCount) {
-        url += `&split_count=${splitCount}`;
+      return getRouterResult(this.endpoint, params);
+    });
+  }
+  expectInputSwap(txb, inputCoin, routers, amountOutLimit, partner) {
+    return __async(this, null, function* () {
+      if (routers.length === 0) {
+        throw new Error("No router found");
       }
-      if (providers) {
-        if (providers.length > 0) {
-          url += `&providers=${providers.join(",")}`;
-        }
+      const splitAmounts = routers.map((router) => router.amountIn.toString());
+      const inputCoinType = routers[0].path[0].from;
+      const outputCoinType = routers[0].path[routers[0].path.length - 1].target;
+      const inputCoins = txb.splitCoins(inputCoin, splitAmounts);
+      const outputCoins = [];
+      for (let i = 0; i < routers.length; i++) {
+        if (routers[i].path.length === 0) {
+          throw new Error("Empty path");
+        }
+        let nextCoin = inputCoins[i];
+        for (const path of routers[i].path) {
+          const dex = this.newDex(path.provider, partner);
+          nextCoin = yield dex.swap(this, txb, path, nextCoin);
+        }
+        outputCoins.push(nextCoin);
       }
-      const response = yield fetch(url);
-      if (!response.ok) {
-        return {
-          amountIn: ZERO,
-          amountOut: ZERO,
-          routes: [],
-          insufficientLiquidity: false,
-          error: {
-            code: 10001 /* NumberTooLarge */,
-            msg: getAggregatorServerErrorMessage(
-              10001 /* NumberTooLarge */
-            )
+      this.transferOrDestoryCoin(txb, inputCoin, inputCoinType);
+      const mergedTargetCointhis = this.checkCoinThresholdAndMergeCoin(
+        txb,
+        outputCoins,
+        outputCoinType,
+        amountOutLimit
+      );
+      return mergedTargetCointhis;
+    });
+  }
+  expectOutputSwap(txb, inputCoin, routers, partner) {
+    return __async(this, null, function* () {
+      const returnCoins = [];
+      const receipts = [];
+      const targetCoins = [];
+      const dex = new Cetus(this.env, partner);
+      for (let i = 0; i < routers.length; i++) {
+        const router = routers[i];
+        for (let j = router.path.length - 1; j >= 0; j--) {
+          const path = router.path[j];
+          const flashSwapResult = dex.flash_swap(this, txb, path, false);
+          returnCoins.unshift(flashSwapResult.targetCoin);
+          receipts.unshift(flashSwapResult.flashReceipt);
+        }
+        let nextRepayCoin = inputCoin;
+        for (let j = 0; j < router.path.length; j++) {
+          const path = router.path[j];
+          const repayResult = dex.repay_flash_swap(
+            this,
+            txb,
+            path,
+            nextRepayCoin,
+            receipts[j]
+          );
+          nextRepayCoin = returnCoins[j];
+          if (j === 0) {
+            inputCoin = repayResult;
+          } else {
+            this.transferOrDestoryCoin(txb, repayResult, path.from);
           }
-        };
+          if (j === router.path.length - 1) {
+            targetCoins.push(nextRepayCoin);
+          }
+        }
       }
-      const data = yield response.json();
-      if (data.data != null) {
-        const res = parseRouterResponse(data.data);
-        return res;
+      const inputCoinType = routers[0].path[0].from;
+      this.transferOrDestoryCoin(txb, inputCoin, inputCoinType);
+      if (targetCoins.length > 1) {
+        const vec = txb.makeMoveVec({ elements: targetCoins.slice(1) });
+        txb.moveCall({
+          target: `${utils.SUI_FRAMEWORK_ADDRESS}::pay::join_vec`,
+          typeArguments: [routers[0].path[routers[0].path.length - 1].target],
+          arguments: [targetCoins[0], vec]
+        });
       }
-      const insufficientLiquidity = data.msg === "liquidity is not enough";
-      return {
-        amountIn: ZERO,
-        amountOut: ZERO,
-        routes: [],
-        insufficientLiquidity,
-        error: {
-          code: 10003 /* InsufficientLiquidity */,
-          msg: getAggregatorServerErrorMessage(
-            10003 /* InsufficientLiquidity */
-          )
-        }
-      };
+      return targetCoins[0];
     });
   }
   swapInPools(params) {
     return __async(this, null, function* () {
       let result;
       try {
-        result = yield swapInPools(this.client, params, this.config);
+        result = yield swapInPools(this.client, params, this.signer);
       } catch (e) {
         console.error("swapInPools error:", e);
         return null;
@@ -6599,100 +6079,168 @@ var AggregatorClient = class {
     });
   }
   routerSwap(params) {
+    return __async(this, null, function* () {
+      const { routers, inputCoin, slippage, byAmountIn, txb, partner } = params;
+      const amountIn = routers.reduce(
+        (acc, router) => acc.add(router.amountIn),
+        new import_bn5.default(0)
+      );
+      const amountOut = routers.reduce(
+        (acc, router) => acc.add(router.amountOut),
+        new import_bn5.default(0)
+      );
+      const amountLimit = CalculateAmountLimit(
+        byAmountIn ? amountOut : amountIn,
+        byAmountIn,
+        slippage
+      );
+      if (byAmountIn) {
+        const targetCoin2 = yield this.expectInputSwap(
+          txb,
+          inputCoin,
+          routers,
+          new import_bn5.default(amountLimit),
+          partner
+        );
+        return targetCoin2;
+      }
+      const splitedInputCoins = txb.splitCoins(inputCoin, [
+        amountLimit.toString()
+      ]);
+      this.transferOrDestoryCoin(txb, inputCoin, routers[0].path[0].from);
+      const targetCoin = yield this.expectOutputSwap(
+        txb,
+        splitedInputCoins[0],
+        routers,
+        partner
+      );
+      return targetCoin;
+    });
+  }
+  // auto build input coin
+  // auto merge, transfer or destory target coin.
+  fastRouterSwap(params) {
     return __async(this, null, function* () {
       const {
-        routers: _,
-        amountIn,
-        amountOut,
+        routers,
         byAmountIn,
         slippage,
-        fromCoinType,
-        targetCoinType,
+        txb,
         partner,
         isMergeTragetCoin,
         refreshAllCoins
       } = params;
+      if (refreshAllCoins || this.allCoins.length === 0) {
+        this.allCoins = yield this.getAllCoins();
+      }
+      const fromCoinType = routers[0].path[0].from;
+      const targetCoinType = routers[0].path[routers[0].path.length - 1].target;
+      const amountIn = routers.reduce(
+        (acc, router) => acc.add(router.amountIn),
+        new import_bn5.default(0)
+      );
+      const amountOut = routers.reduce(
+        (acc, router) => acc.add(router.amountOut),
+        new import_bn5.default(0)
+      );
       const amountLimit = CalculateAmountLimit(
         byAmountIn ? amountOut : amountIn,
         byAmountIn,
         slippage
       );
-      const txb = new transactions.Transaction();
-      if (refreshAllCoins || this.allCoins.length === 0) {
-        this.allCoins = yield this.getAllCoins();
-      }
-      const allCoins = this.allCoins;
-      let targetCoins = [];
-      if (byAmountIn) {
-        const buildFromCoinRes = buildInputCoin(
-          txb,
-          allCoins,
-          BigInt(amountIn.toString()),
-          fromCoinType
-        );
-        const fromCoin = buildFromCoinRes.targetCoin;
-        const swapedCoins = yield expectInputRouterSwap(
-          this.client,
-          params,
-          txb,
-          fromCoin,
-          this.config,
-          partner
-        );
-        const mergedCoin = checkCoinThresholdAndMergeCoin(
-          txb,
-          swapedCoins,
-          targetCoinType,
-          amountLimit,
-          this.config
-        );
-        targetCoins.push(mergedCoin);
-      } else {
-        const fromCoin = buildInputCoin(
-          txb,
-          allCoins,
-          BigInt(amountLimit),
-          fromCoinType
-        ).targetCoin;
-        const swapedCoins = yield expectOutputRouterSwap(
-          params,
-          txb,
-          fromCoin,
-          this.config,
-          partner
-        );
-        targetCoins.push(...swapedCoins);
-      }
+      const amount = byAmountIn ? amountIn : amountLimit;
+      const buildFromCoinRes = buildInputCoin(
+        txb,
+        this.allCoins,
+        BigInt(amount.toString()),
+        fromCoinType
+      );
+      const targetCoin = yield this.routerSwap({
+        routers,
+        inputCoin: buildFromCoinRes.targetCoin,
+        slippage,
+        byAmountIn,
+        txb,
+        partner
+      });
       if (isMergeTragetCoin) {
         const targetCoinRes = buildInputCoin(
           txb,
-          allCoins,
+          this.allCoins,
           BigInt(0),
           targetCoinType
         );
-        txb.mergeCoins(targetCoinRes.targetCoin, targetCoins);
+        txb.mergeCoins(targetCoinRes.targetCoin, [targetCoin]);
         if (targetCoinRes.isMintZeroCoin) {
-          transferOrDestoryCoin(
+          this.transferOrDestoryCoin(
             txb,
             targetCoinRes.targetCoin,
-            targetCoinType,
-            this.config
+            targetCoinType
           );
         }
       } else {
-        if (targetCoins.length > 1) {
-          const vec = txb.makeMoveVec({ elements: targetCoins.slice(1) });
-          txb.moveCall({
-            target: createTarget(utils.SUI_FRAMEWORK_ADDRESS, PAY_MODULE, JOIN_FUNC),
-            typeArguments: [targetCoinType],
-            arguments: [targetCoins[0], vec]
-          });
-        }
-        transferOrDestoryCoin(txb, targetCoins[0], targetCoinType, this.config);
+        this.transferOrDestoryCoin(txb, targetCoin, targetCoinType);
       }
-      return txb;
     });
   }
+  publishedAt() {
+    if (this.env === 0 /* Mainnet */) {
+      return "0x9fd702cf1a8db5a2e99be20be6750d22ec75c30d57e3d9ccbc37c9b4ad7bef21";
+    } else {
+      return "0x0";
+    }
+  }
+  transferOrDestoryCoin(txb, coin, coinType) {
+    txb.moveCall({
+      target: `${this.publishedAt()}::utils::transfer_or_destroy_coin`,
+      typeArguments: [coinType],
+      arguments: [coin]
+    });
+  }
+  checkCoinThresholdAndMergeCoin(txb, coins, coinType, amountLimit) {
+    let targetCoin = coins[0];
+    if (coins.length > 1) {
+      let vec = txb.makeMoveVec({ elements: coins.slice(1) });
+      txb.moveCall({
+        target: `${utils.SUI_FRAMEWORK_ADDRESS}::pay::join_vec`,
+        typeArguments: [coinType],
+        arguments: [coins[0], vec]
+      });
+      targetCoin = coins[0];
+    }
+    txb.moveCall({
+      target: `${this.publishedAt()}::utils::check_coin_threshold`,
+      typeArguments: [coinType],
+      arguments: [targetCoin, txb.pure.u64(amountLimit.toString())]
+    });
+    return targetCoin;
+  }
+  newDex(provider, partner) {
+    switch (provider) {
+      case CETUS:
+        return new Cetus(this.env, partner);
+      case DEEPBOOKV2:
+        return new DeepbookV2(this.env);
+      case KRIYA:
+        return new KriyaV2(this.env);
+      case KRIYAV3:
+        return new KriyaV3(this.env);
+      case FLOWXV2:
+        return new FlowxV2(this.env);
+      case TURBOS:
+        return new Turbos(this.env);
+      case AFTERMATH:
+        return new Aftermath(this.env);
+      case HAEDAL:
+        return new Haedal(this.env);
+      case AFSUI:
+        return new Afsui(this.env);
+      case VOLO:
+        return new Volo(this.env);
+      default:
+        throw new Error(`Unsupported dex ${provider}`);
+    }
+  }
   signAndExecuteTransaction(txb, signer) {
     return __async(this, null, function* () {
       const res = yield this.client.signAndExecuteTransaction({
@@ -6712,7 +6260,7 @@ var AggregatorClient = class {
     return __async(this, null, function* () {
       const res = yield this.client.devInspectTransactionBlock({
         transactionBlock: txb,
-        sender: this.wallet
+        sender: this.signer
       });
       return res;
     });
@@ -6729,19 +6277,19 @@ var AggregatorClient = class {
 };
 function parseRouterResponse(data) {
   return {
-    amountIn: new import_bn4.default(data.amount_in.toString()),
-    amountOut: new import_bn4.default(data.amount_out.toString()),
+    amountIn: new import_bn5.default(data.amount_in.toString()),
+    amountOut: new import_bn5.default(data.amount_out.toString()),
     insufficientLiquidity: false,
     routes: data.routes.map((route) => {
       return {
         path: route.path.map((path) => {
           var _a, _b;
           let version;
-          if (path.provider === AFTERMATH_AMM) {
+          if (path.provider === AFTERMATH) {
             version = path.extended_details.aftermath_pool_flatness === 0 ? "v2" : "v3";
           }
           let extendedDetails;
-          if (path.provider === TURBOS_DEX || path.provider === AFTERMATH_AMM) {
+          if (path.provider === TURBOS || path.provider === AFTERMATH) {
             extendedDetails = {
               aftermathLpSupplyType: (_a = path.extended_details) == null ? void 0 : _a.aftermath_lp_supply_type,
               turbosFeeType: (_b = path.extended_details) == null ? void 0 : _b.turbos_fee_type
@@ -6749,7 +6297,7 @@ function parseRouterResponse(data) {
           }
           return {
             id: path.id,
-            a2b: path.direction,
+            direction: path.direction,
             provider: path.provider,
             from: path.from,
             target: path.target,
@@ -6760,13 +6308,93 @@ function parseRouterResponse(data) {
             version
           };
         }),
-        amountIn: new import_bn4.default(route.amount_in.toString()),
-        amountOut: new import_bn4.default(route.amount_out.toString()),
+        amountIn: new import_bn5.default(route.amount_in.toString()),
+        amountOut: new import_bn5.default(route.amount_out.toString()),
         initialPrice: new decimal_default(route.initial_price.toString())
       };
     })
   };
 }
+
+// src/transaction/index.ts
+var CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
+
+// src/api.ts
+function getRouterResult(endpoint, params) {
+  return __async(this, null, function* () {
+    const {
+      from,
+      target,
+      amount,
+      byAmountIn,
+      depth,
+      splitAlgorithm,
+      splitFactor,
+      splitCount,
+      providers
+    } = params;
+    const fromCoin = completionCoin(from);
+    const targetCoin = completionCoin(target);
+    let url = `${endpoint}?from=${fromCoin}&target=${targetCoin}&amount=${amount.toString()}&by_amount_in=${byAmountIn}`;
+    if (depth) {
+      url += `&depth=${depth}`;
+    }
+    if (splitAlgorithm) {
+      url += `&split_algorithm=${splitAlgorithm}`;
+    }
+    if (splitFactor) {
+      url += `&split_factor=${splitFactor}`;
+    }
+    if (splitCount) {
+      url += `&split_count=${splitCount}`;
+    }
+    if (providers) {
+      if (providers.length > 0) {
+        url += `&providers=${providers.join(",")}`;
+      }
+    }
+    const response = yield fetch(url);
+    if (!response.ok) {
+      return {
+        amountIn: ZERO,
+        amountOut: ZERO,
+        routes: [],
+        insufficientLiquidity: false,
+        error: {
+          code: 10001 /* NumberTooLarge */,
+          msg: getAggregatorServerErrorMessage(
+            10001 /* NumberTooLarge */
+          )
+        }
+      };
+    }
+    const data = yield response.json();
+    if (data.data != null) {
+      const res = parseRouterResponse(data.data);
+      return res;
+    }
+    const insufficientLiquidity = data.msg === "liquidity is not enough";
+    return {
+      amountIn: ZERO,
+      amountOut: ZERO,
+      routes: [],
+      insufficientLiquidity,
+      error: {
+        code: 10003 /* InsufficientLiquidity */,
+        msg: getAggregatorServerErrorMessage(
+          10003 /* InsufficientLiquidity */
+        )
+      }
+    };
+  });
+}
+
+// src/index.ts
+var Env = /* @__PURE__ */ ((Env2) => {
+  Env2[Env2["Mainnet"] = 0] = "Mainnet";
+  Env2[Env2["Testnet"] = 1] = "Testnet";
+  return Env2;
+})(Env || {});
 /*! Bundled license information:
 
 decimal.js/decimal.mjs:
@@ -6779,82 +6407,32 @@ decimal.js/decimal.mjs:
    *)
 */
 
-exports.AFTERMATH_AMM = AFTERMATH_AMM;
-exports.AFTERMATH_MODULE = AFTERMATH_MODULE;
-exports.AGGREGATOR = AGGREGATOR;
-exports.AggregatorClient = AggregatorClient;
-exports.AggregatorConfig = AggregatorConfig;
-exports.CETUS_DEX = CETUS_DEX;
-exports.CETUS_MODULE = CETUS_MODULE;
-exports.CETUS_PUBLISHED_AT = CETUS_PUBLISHED_AT;
-exports.CHECK_COINS_THRESHOLD_FUNC = CHECK_COINS_THRESHOLD_FUNC;
+exports.AFSUI = AFSUI;
+exports.AFTERMATH = AFTERMATH;
+exports.AggregatorClient = AggregatorClient5;
+exports.CETUS = CETUS;
 exports.CLOCK_ADDRESS = CLOCK_ADDRESS;
-exports.CoinInfoAddress = CoinInfoAddress;
-exports.CoinStoreAddress = CoinStoreAddress;
-exports.DEEPBOOK_CLOB_V2_MODULE = DEEPBOOK_CLOB_V2_MODULE;
-exports.DEEPBOOK_CUSTODIAN_V2_MODULE = DEEPBOOK_CUSTODIAN_V2_MODULE;
-exports.DEEPBOOK_DEX = DEEPBOOK_DEX;
-exports.DEEPBOOK_MODULE = DEEPBOOK_MODULE;
-exports.DEEPBOOK_PACKAGE_ID = DEEPBOOK_PACKAGE_ID;
-exports.DEEPBOOK_PUBLISHED_AT = DEEPBOOK_PUBLISHED_AT;
-exports.ENV = ENV;
-exports.FLOWX_AMM = FLOWX_AMM;
-exports.FLOWX_AMM_MODULE = FLOWX_AMM_MODULE;
-exports.FlashSwapA2BFunc = FlashSwapA2BFunc;
-exports.FlashSwapB2AFunc = FlashSwapB2AFunc;
-exports.FlashSwapFunc = FlashSwapFunc;
-exports.FlashSwapWithPartnerA2BFunc = FlashSwapWithPartnerA2BFunc;
-exports.FlashSwapWithPartnerB2AFunc = FlashSwapWithPartnerB2AFunc;
-exports.FlashSwapWithPartnerFunc = FlashSwapWithPartnerFunc;
-exports.INTEGRATE = INTEGRATE;
-exports.JOIN_FUNC = JOIN_FUNC;
-exports.KRIYA_DEX = KRIYA_DEX;
-exports.KRIYA_MODULE = KRIYA_MODULE;
-exports.MAINNET_AFTERMATH_INSURANCE_FUND_ID = MAINNET_AFTERMATH_INSURANCE_FUND_ID;
-exports.MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = MAINNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID;
-exports.MAINNET_AFTERMATH_REFERRAL_VAULT_ID = MAINNET_AFTERMATH_REFERRAL_VAULT_ID;
-exports.MAINNET_AFTERMATH_REGISTRY_ID = MAINNET_AFTERMATH_REGISTRY_ID;
-exports.MAINNET_AFTERMATH_TREASURY_ID = MAINNET_AFTERMATH_TREASURY_ID;
-exports.MAINNET_CETUS_GLOBAL_CONFIG_ID = MAINNET_CETUS_GLOBAL_CONFIG_ID;
-exports.MAINNET_FLOWX_AMM_CONTAINER_ID = MAINNET_FLOWX_AMM_CONTAINER_ID;
+exports.DEEPBOOKV2 = DEEPBOOKV2;
+exports.Env = Env;
+exports.FLOWXV2 = FLOWXV2;
+exports.HAEDAL = HAEDAL;
+exports.KRIYA = KRIYA;
+exports.KRIYAV3 = KRIYAV3;
 exports.ONE = ONE;
-exports.PAY_MODULE = PAY_MODULE;
-exports.POOL_MODULT = POOL_MODULT;
-exports.REPAY_FLASH_SWAP_A2B_FUNC = REPAY_FLASH_SWAP_A2B_FUNC;
-exports.REPAY_FLASH_SWAP_B2A_FUNC = REPAY_FLASH_SWAP_B2A_FUNC;
-exports.REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC = REPAY_FLASH_SWAP_WITH_PARTNER_A2B_FUNC;
-exports.REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC = REPAY_FLASH_SWAP_WITH_PARTNER_B2A_FUNC;
-exports.RepayFalshSwapFunc = RepayFalshSwapFunc;
-exports.RepayFlashSwapWithPartnerFunc = RepayFlashSwapWithPartnerFunc;
-exports.SWAP_A2B_FUNC = SWAP_A2B_FUNC;
-exports.SWAP_B2A_FUNC = SWAP_B2A_FUNC;
-exports.SuiZeroCoinFn = SuiZeroCoinFn;
 exports.TEN_POW_NINE = TEN_POW_NINE;
-exports.TESTNET_AFTERMATH_INSURANCE_FUND_ID = TESTNET_AFTERMATH_INSURANCE_FUND_ID;
-exports.TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID = TESTNET_AFTERMATH_PROTOCOL_FEE_VAULT_ID;
-exports.TESTNET_AFTERMATH_REFERRAL_VAULT_ID = TESTNET_AFTERMATH_REFERRAL_VAULT_ID;
-exports.TESTNET_AFTERMATH_REGISTRY_ID = TESTNET_AFTERMATH_REGISTRY_ID;
-exports.TESTNET_AFTERMATH_TREASURY_ID = TESTNET_AFTERMATH_TREASURY_ID;
-exports.TESTNET_CETUS_GLOBAL_CONFIG_ID = TESTNET_CETUS_GLOBAL_CONFIG_ID;
-exports.TESTNET_FLOWX_AMM_CONTAINER_ID = TESTNET_FLOWX_AMM_CONTAINER_ID;
-exports.TRANSFER_ACCOUNT_CAP = TRANSFER_ACCOUNT_CAP;
-exports.TRANSFER_OR_DESTORY_COIN_FUNC = TRANSFER_OR_DESTORY_COIN_FUNC;
-exports.TURBOS_DEX = TURBOS_DEX;
-exports.TURBOS_MODULE = TURBOS_MODULE;
-exports.TURBOS_VERSIONED = TURBOS_VERSIONED;
+exports.TURBOS = TURBOS;
 exports.TWO = TWO;
 exports.U128 = U128;
 exports.U64_MAX = U64_MAX;
 exports.U64_MAX_BN = U64_MAX_BN;
-exports.UTILS_MODULE = UTILS_MODULE;
+exports.VOLO = VOLO;
 exports.ZERO = ZERO;
 exports.composeType = composeType;
 exports.createTarget = createTarget;
-exports.expectInputRouterSwap = expectInputRouterSwap;
-exports.expectOutputRouterSwap = expectOutputRouterSwap;
 exports.extractAddressFromType = extractAddressFromType;
 exports.extractStructTagFromType = extractStructTagFromType;
 exports.fixSuiObjectId = fixSuiObjectId;
+exports.getRouterResult = getRouterResult;
 exports.isSortedSymbols = isSortedSymbols;
 exports.normalizeCoinType = normalizeCoinType;
 exports.parseRouterResponse = parseRouterResponse;