@jpool/bond-sdk 0.10.4 → 0.10.6

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { utils, Program, AnchorProvider, BN } from '@coral-xyz/anchor';
-import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, ACCOUNT_SIZE, AccountLayout } from '@solana/spl-token';
-import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { getAssociatedTokenAddressSync, ACCOUNT_SIZE, AccountLayout } from '@solana/spl-token';
+import { PublicKey, Transaction, LAMPORTS_PER_SOL } from '@solana/web3.js';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1815,8 +1815,8 @@ var require_bn = __commonJS({
         ctor.prototype = new TempCtor();
         ctor.prototype.constructor = ctor;
       }
-      function BN3(number, base, endian) {
-        if (BN3.isBN(number)) {
+      function BN4(number, base, endian) {
+        if (BN4.isBN(number)) {
           return number;
         }
         this.negative = 0;
@@ -1832,12 +1832,12 @@ var require_bn = __commonJS({
         }
       }
       if (typeof module2 === "object") {
-        module2.exports = BN3;
+        module2.exports = BN4;
       } else {
-        exports2.BN = BN3;
+        exports2.BN = BN4;
       }
-      BN3.BN = BN3;
-      BN3.wordSize = 26;
+      BN4.BN = BN4;
+      BN4.wordSize = 26;
       var Buffer2;
       try {
         if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
@@ -1847,21 +1847,21 @@ var require_bn = __commonJS({
         }
       } catch (e) {
       }
-      BN3.isBN = function isBN(num) {
-        if (num instanceof BN3) {
+      BN4.isBN = function isBN(num) {
+        if (num instanceof BN4) {
           return true;
         }
-        return num !== null && typeof num === "object" && num.constructor.wordSize === BN3.wordSize && Array.isArray(num.words);
+        return num !== null && typeof num === "object" && num.constructor.wordSize === BN4.wordSize && Array.isArray(num.words);
       };
-      BN3.max = function max(left, right) {
+      BN4.max = function max(left, right) {
         if (left.cmp(right) > 0) return left;
         return right;
       };
-      BN3.min = function min(left, right) {
+      BN4.min = function min(left, right) {
         if (left.cmp(right) < 0) return left;
         return right;
       };
-      BN3.prototype._init = function init(number, base, endian) {
+      BN4.prototype._init = function init(number, base, endian) {
         if (typeof number === "number") {
           return this._initNumber(number, base, endian);
         }
@@ -1889,7 +1889,7 @@ var require_bn = __commonJS({
           }
         }
       };
-      BN3.prototype._initNumber = function _initNumber(number, base, endian) {
+      BN4.prototype._initNumber = function _initNumber(number, base, endian) {
         if (number < 0) {
           this.negative = 1;
           number = -number;
@@ -1915,7 +1915,7 @@ var require_bn = __commonJS({
         if (endian !== "le") return;
         this._initArray(this.toArray(), base, endian);
       };
-      BN3.prototype._initArray = function _initArray(number, base, endian) {
+      BN4.prototype._initArray = function _initArray(number, base, endian) {
         assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
@@ -1973,7 +1973,7 @@ var require_bn = __commonJS({
         }
         return r;
       }
-      BN3.prototype._parseHex = function _parseHex(number, start, endian) {
+      BN4.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++) {
@@ -2029,7 +2029,7 @@ var require_bn = __commonJS({
         }
         return r;
       }
-      BN3.prototype._parseBase = function _parseBase(number, base, start) {
+      BN4.prototype._parseBase = function _parseBase(number, base, start) {
         this.words = [0];
         this.length = 1;
         for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
@@ -2065,7 +2065,7 @@ var require_bn = __commonJS({
         }
         this._strip();
       };
-      BN3.prototype.copy = function copy(dest) {
+      BN4.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];
@@ -2080,27 +2080,27 @@ var require_bn = __commonJS({
         dest.negative = src.negative;
         dest.red = src.red;
       }
-      BN3.prototype._move = function _move(dest) {
+      BN4.prototype._move = function _move(dest) {
         move(dest, this);
       };
-      BN3.prototype.clone = function clone() {
-        var r = new BN3(null);
+      BN4.prototype.clone = function clone() {
+        var r = new BN4(null);
         this.copy(r);
         return r;
       };
-      BN3.prototype._expand = function _expand(size) {
+      BN4.prototype._expand = function _expand(size) {
         while (this.length < size) {
           this.words[this.length++] = 0;
         }
         return this;
       };
-      BN3.prototype._strip = function strip() {
+      BN4.prototype._strip = function strip() {
         while (this.length > 1 && this.words[this.length - 1] === 0) {
           this.length--;
         }
         return this._normSign();
       };
-      BN3.prototype._normSign = function _normSign() {
+      BN4.prototype._normSign = function _normSign() {
         if (this.length === 1 && this.words[0] === 0) {
           this.negative = 0;
         }
@@ -2108,12 +2108,12 @@ var require_bn = __commonJS({
       };
       if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
         try {
-          BN3.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
+          BN4.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
         } catch (e) {
-          BN3.prototype.inspect = inspect;
+          BN4.prototype.inspect = inspect;
         }
       } else {
-        BN3.prototype.inspect = inspect;
+        BN4.prototype.inspect = inspect;
       }
       function inspect() {
         return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
@@ -2224,7 +2224,7 @@ var require_bn = __commonJS({
         52521875,
         60466176
       ];
-      BN3.prototype.toString = function toString(base, padding) {
+      BN4.prototype.toString = function toString(base, padding) {
         base = base || 10;
         padding = padding | 0 || 1;
         var out;
@@ -2286,7 +2286,7 @@ var require_bn = __commonJS({
         }
         assert(false, "Base should be between 2 and 36");
       };
-      BN3.prototype.toNumber = function toNumber() {
+      BN4.prototype.toNumber = function toNumber() {
         var ret = this.words[0];
         if (this.length === 2) {
           ret += this.words[1] * 67108864;
@@ -2297,15 +2297,15 @@ var require_bn = __commonJS({
         }
         return this.negative !== 0 ? -ret : ret;
       };
-      BN3.prototype.toJSON = function toJSON() {
+      BN4.prototype.toJSON = function toJSON() {
         return this.toString(16, 2);
       };
       if (Buffer2) {
-        BN3.prototype.toBuffer = function toBuffer(endian, length) {
+        BN4.prototype.toBuffer = function toBuffer(endian, length) {
           return this.toArrayLike(Buffer2, endian, length);
         };
       }
-      BN3.prototype.toArray = function toArray(endian, length) {
+      BN4.prototype.toArray = function toArray(endian, length) {
         return this.toArrayLike(Array, endian, length);
       };
       var allocate = function allocate2(ArrayType, size) {
@@ -2314,7 +2314,7 @@ var require_bn = __commonJS({
         }
         return new ArrayType(size);
       };
-      BN3.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
+      BN4.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
         this._strip();
         var byteLength = this.byteLength();
         var reqLength = length || Math.max(1, byteLength);
@@ -2325,7 +2325,7 @@ var require_bn = __commonJS({
         this["_toArrayLike" + postfix](res, byteLength);
         return res;
       };
-      BN3.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
+      BN4.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
         var position = 0;
         var carry = 0;
         for (var i = 0, shift = 0; i < this.length; i++) {
@@ -2355,7 +2355,7 @@ var require_bn = __commonJS({
           }
         }
       };
-      BN3.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
+      BN4.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
         var position = res.length - 1;
         var carry = 0;
         for (var i = 0, shift = 0; i < this.length; i++) {
@@ -2386,11 +2386,11 @@ var require_bn = __commonJS({
         }
       };
       if (Math.clz32) {
-        BN3.prototype._countBits = function _countBits(w) {
+        BN4.prototype._countBits = function _countBits(w) {
           return 32 - Math.clz32(w);
         };
       } else {
-        BN3.prototype._countBits = function _countBits(w) {
+        BN4.prototype._countBits = function _countBits(w) {
           var t = w;
           var r = 0;
           if (t >= 4096) {
@@ -2412,7 +2412,7 @@ var require_bn = __commonJS({
           return r + t;
         };
       }
-      BN3.prototype._zeroBits = function _zeroBits(w) {
+      BN4.prototype._zeroBits = function _zeroBits(w) {
         if (w === 0) return 26;
         var t = w;
         var r = 0;
@@ -2437,7 +2437,7 @@ var require_bn = __commonJS({
         }
         return r;
       };
-      BN3.prototype.bitLength = function bitLength() {
+      BN4.prototype.bitLength = function bitLength() {
         var w = this.words[this.length - 1];
         var hi = this._countBits(w);
         return (this.length - 1) * 26 + hi;
@@ -2451,7 +2451,7 @@ var require_bn = __commonJS({
         }
         return w;
       }
-      BN3.prototype.zeroBits = function zeroBits() {
+      BN4.prototype.zeroBits = function zeroBits() {
         if (this.isZero()) return 0;
         var r = 0;
         for (var i = 0; i < this.length; i++) {
@@ -2461,34 +2461,34 @@ var require_bn = __commonJS({
         }
         return r;
       };
-      BN3.prototype.byteLength = function byteLength() {
+      BN4.prototype.byteLength = function byteLength() {
         return Math.ceil(this.bitLength() / 8);
       };
-      BN3.prototype.toTwos = function toTwos(width) {
+      BN4.prototype.toTwos = function toTwos(width) {
         if (this.negative !== 0) {
           return this.abs().inotn(width).iaddn(1);
         }
         return this.clone();
       };
-      BN3.prototype.fromTwos = function fromTwos(width) {
+      BN4.prototype.fromTwos = function fromTwos(width) {
         if (this.testn(width - 1)) {
           return this.notn(width).iaddn(1).ineg();
         }
         return this.clone();
       };
-      BN3.prototype.isNeg = function isNeg() {
+      BN4.prototype.isNeg = function isNeg() {
         return this.negative !== 0;
       };
-      BN3.prototype.neg = function neg() {
+      BN4.prototype.neg = function neg() {
         return this.clone().ineg();
       };
-      BN3.prototype.ineg = function ineg() {
+      BN4.prototype.ineg = function ineg() {
         if (!this.isZero()) {
           this.negative ^= 1;
         }
         return this;
       };
-      BN3.prototype.iuor = function iuor(num) {
+      BN4.prototype.iuor = function iuor(num) {
         while (this.length < num.length) {
           this.words[this.length++] = 0;
         }
@@ -2497,19 +2497,19 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.ior = function ior(num) {
+      BN4.prototype.ior = function ior(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuor(num);
       };
-      BN3.prototype.or = function or(num) {
+      BN4.prototype.or = function or(num) {
         if (this.length > num.length) return this.clone().ior(num);
         return num.clone().ior(this);
       };
-      BN3.prototype.uor = function uor(num) {
+      BN4.prototype.uor = function uor(num) {
         if (this.length > num.length) return this.clone().iuor(num);
         return num.clone().iuor(this);
       };
-      BN3.prototype.iuand = function iuand(num) {
+      BN4.prototype.iuand = function iuand(num) {
         var b;
         if (this.length > num.length) {
           b = num;
@@ -2522,19 +2522,19 @@ var require_bn = __commonJS({
         this.length = b.length;
         return this._strip();
       };
-      BN3.prototype.iand = function iand(num) {
+      BN4.prototype.iand = function iand(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuand(num);
       };
-      BN3.prototype.and = function and(num) {
+      BN4.prototype.and = function and(num) {
         if (this.length > num.length) return this.clone().iand(num);
         return num.clone().iand(this);
       };
-      BN3.prototype.uand = function uand(num) {
+      BN4.prototype.uand = function uand(num) {
         if (this.length > num.length) return this.clone().iuand(num);
         return num.clone().iuand(this);
       };
-      BN3.prototype.iuxor = function iuxor(num) {
+      BN4.prototype.iuxor = function iuxor(num) {
         var a;
         var b;
         if (this.length > num.length) {
@@ -2555,19 +2555,19 @@ var require_bn = __commonJS({
         this.length = a.length;
         return this._strip();
       };
-      BN3.prototype.ixor = function ixor(num) {
+      BN4.prototype.ixor = function ixor(num) {
         assert((this.negative | num.negative) === 0);
         return this.iuxor(num);
       };
-      BN3.prototype.xor = function xor(num) {
+      BN4.prototype.xor = function xor(num) {
         if (this.length > num.length) return this.clone().ixor(num);
         return num.clone().ixor(this);
       };
-      BN3.prototype.uxor = function uxor(num) {
+      BN4.prototype.uxor = function uxor(num) {
         if (this.length > num.length) return this.clone().iuxor(num);
         return num.clone().iuxor(this);
       };
-      BN3.prototype.inotn = function inotn(width) {
+      BN4.prototype.inotn = function inotn(width) {
         assert(typeof width === "number" && width >= 0);
         var bytesNeeded = Math.ceil(width / 26) | 0;
         var bitsLeft = width % 26;
@@ -2583,10 +2583,10 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.notn = function notn(width) {
+      BN4.prototype.notn = function notn(width) {
         return this.clone().inotn(width);
       };
-      BN3.prototype.setn = function setn(bit, val) {
+      BN4.prototype.setn = function setn(bit, val) {
         assert(typeof bit === "number" && bit >= 0);
         var off = bit / 26 | 0;
         var wbit = bit % 26;
@@ -2598,7 +2598,7 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.iadd = function iadd(num) {
+      BN4.prototype.iadd = function iadd(num) {
         var r;
         if (this.negative !== 0 && num.negative === 0) {
           this.negative = 0;
@@ -2641,7 +2641,7 @@ var require_bn = __commonJS({
         }
         return this;
       };
-      BN3.prototype.add = function add(num) {
+      BN4.prototype.add = function add(num) {
         var res;
         if (num.negative !== 0 && this.negative === 0) {
           num.negative = 0;
@@ -2657,7 +2657,7 @@ var require_bn = __commonJS({
         if (this.length > num.length) return this.clone().iadd(num);
         return num.clone().iadd(this);
       };
-      BN3.prototype.isub = function isub(num) {
+      BN4.prototype.isub = function isub(num) {
         if (num.negative !== 0) {
           num.negative = 0;
           var r = this.iadd(num);
@@ -2706,7 +2706,7 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.sub = function sub(num) {
+      BN4.prototype.sub = function sub(num) {
         return this.clone().isub(num);
       };
       function smallMulTo(self, num, out) {
@@ -3334,7 +3334,7 @@ var require_bn = __commonJS({
       function jumboMulTo(self, num, out) {
         return bigMulTo(self, num, out);
       }
-      BN3.prototype.mulTo = function mulTo(num, out) {
+      BN4.prototype.mulTo = function mulTo(num, out) {
         var res;
         var len = this.length + num.length;
         if (this.length === 10 && num.length === 10) {
@@ -3348,20 +3348,20 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN3.prototype.mul = function mul(num) {
-        var out = new BN3(null);
+      BN4.prototype.mul = function mul(num) {
+        var out = new BN4(null);
         out.words = new Array(this.length + num.length);
         return this.mulTo(num, out);
       };
-      BN3.prototype.mulf = function mulf(num) {
-        var out = new BN3(null);
+      BN4.prototype.mulf = function mulf(num) {
+        var out = new BN4(null);
         out.words = new Array(this.length + num.length);
         return jumboMulTo(this, num, out);
       };
-      BN3.prototype.imul = function imul(num) {
+      BN4.prototype.imul = function imul(num) {
         return this.clone().mulTo(num, this);
       };
-      BN3.prototype.imuln = function imuln(num) {
+      BN4.prototype.imuln = function imuln(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(typeof num === "number");
@@ -3382,18 +3382,18 @@ var require_bn = __commonJS({
         this.length = num === 0 ? 1 : this.length;
         return isNegNum ? this.ineg() : this;
       };
-      BN3.prototype.muln = function muln(num) {
+      BN4.prototype.muln = function muln(num) {
         return this.clone().imuln(num);
       };
-      BN3.prototype.sqr = function sqr() {
+      BN4.prototype.sqr = function sqr() {
         return this.mul(this);
       };
-      BN3.prototype.isqr = function isqr() {
+      BN4.prototype.isqr = function isqr() {
         return this.imul(this.clone());
       };
-      BN3.prototype.pow = function pow(num) {
+      BN4.prototype.pow = function pow(num) {
         var w = toBitArray(num);
-        if (w.length === 0) return new BN3(1);
+        if (w.length === 0) return new BN4(1);
         var res = this;
         for (var i = 0; i < w.length; i++, res = res.sqr()) {
           if (w[i] !== 0) break;
@@ -3406,7 +3406,7 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN3.prototype.iushln = function iushln(bits) {
+      BN4.prototype.iushln = function iushln(bits) {
         assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
@@ -3436,11 +3436,11 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.ishln = function ishln(bits) {
+      BN4.prototype.ishln = function ishln(bits) {
         assert(this.negative === 0);
         return this.iushln(bits);
       };
-      BN3.prototype.iushrn = function iushrn(bits, hint, extended) {
+      BN4.prototype.iushrn = function iushrn(bits, hint, extended) {
         assert(typeof bits === "number" && bits >= 0);
         var h;
         if (hint) {
@@ -3484,23 +3484,23 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.ishrn = function ishrn(bits, hint, extended) {
+      BN4.prototype.ishrn = function ishrn(bits, hint, extended) {
         assert(this.negative === 0);
         return this.iushrn(bits, hint, extended);
       };
-      BN3.prototype.shln = function shln(bits) {
+      BN4.prototype.shln = function shln(bits) {
         return this.clone().ishln(bits);
       };
-      BN3.prototype.ushln = function ushln(bits) {
+      BN4.prototype.ushln = function ushln(bits) {
         return this.clone().iushln(bits);
       };
-      BN3.prototype.shrn = function shrn(bits) {
+      BN4.prototype.shrn = function shrn(bits) {
         return this.clone().ishrn(bits);
       };
-      BN3.prototype.ushrn = function ushrn(bits) {
+      BN4.prototype.ushrn = function ushrn(bits) {
         return this.clone().iushrn(bits);
       };
-      BN3.prototype.testn = function testn(bit) {
+      BN4.prototype.testn = function testn(bit) {
         assert(typeof bit === "number" && bit >= 0);
         var r = bit % 26;
         var s = (bit - r) / 26;
@@ -3509,7 +3509,7 @@ var require_bn = __commonJS({
         var w = this.words[s];
         return !!(w & q);
       };
-      BN3.prototype.imaskn = function imaskn(bits) {
+      BN4.prototype.imaskn = function imaskn(bits) {
         assert(typeof bits === "number" && bits >= 0);
         var r = bits % 26;
         var s = (bits - r) / 26;
@@ -3527,10 +3527,10 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.maskn = function maskn(bits) {
+      BN4.prototype.maskn = function maskn(bits) {
         return this.clone().imaskn(bits);
       };
-      BN3.prototype.iaddn = function iaddn(num) {
+      BN4.prototype.iaddn = function iaddn(num) {
         assert(typeof num === "number");
         assert(num < 67108864);
         if (num < 0) return this.isubn(-num);
@@ -3547,7 +3547,7 @@ var require_bn = __commonJS({
         }
         return this._iaddn(num);
       };
-      BN3.prototype._iaddn = function _iaddn(num) {
+      BN4.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;
@@ -3560,7 +3560,7 @@ var require_bn = __commonJS({
         this.length = Math.max(this.length, i + 1);
         return this;
       };
-      BN3.prototype.isubn = function isubn(num) {
+      BN4.prototype.isubn = function isubn(num) {
         assert(typeof num === "number");
         assert(num < 67108864);
         if (num < 0) return this.iaddn(-num);
@@ -3582,20 +3582,20 @@ var require_bn = __commonJS({
         }
         return this._strip();
       };
-      BN3.prototype.addn = function addn(num) {
+      BN4.prototype.addn = function addn(num) {
         return this.clone().iaddn(num);
       };
-      BN3.prototype.subn = function subn(num) {
+      BN4.prototype.subn = function subn(num) {
         return this.clone().isubn(num);
       };
-      BN3.prototype.iabs = function iabs() {
+      BN4.prototype.iabs = function iabs() {
         this.negative = 0;
         return this;
       };
-      BN3.prototype.abs = function abs() {
+      BN4.prototype.abs = function abs() {
         return this.clone().iabs();
       };
-      BN3.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
+      BN4.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
         var len = num.length + shift;
         var i;
         this._expand(len);
@@ -3624,7 +3624,7 @@ var require_bn = __commonJS({
         this.negative = 1;
         return this._strip();
       };
-      BN3.prototype._wordDiv = function _wordDiv(num, mode) {
+      BN4.prototype._wordDiv = function _wordDiv(num, mode) {
         var shift = this.length - num.length;
         var a = this.clone();
         var b = num;
@@ -3639,7 +3639,7 @@ var require_bn = __commonJS({
         var m = a.length - b.length;
         var q;
         if (mode !== "mod") {
-          q = new BN3(null);
+          q = new BN4(null);
           q.length = m + 1;
           q.words = new Array(q.length);
           for (var i = 0; i < q.length; i++) {
@@ -3681,12 +3681,12 @@ var require_bn = __commonJS({
           mod: a
         };
       };
-      BN3.prototype.divmod = function divmod(num, mode, positive) {
+      BN4.prototype.divmod = function divmod(num, mode, positive) {
         assert(!num.isZero());
         if (this.isZero()) {
           return {
-            div: new BN3(0),
-            mod: new BN3(0)
+            div: new BN4(0),
+            mod: new BN4(0)
           };
         }
         var div, mod, res;
@@ -3731,7 +3731,7 @@ var require_bn = __commonJS({
         }
         if (num.length > this.length || this.cmp(num) < 0) {
           return {
-            div: new BN3(0),
+            div: new BN4(0),
             mod: this
           };
         }
@@ -3745,26 +3745,26 @@ var require_bn = __commonJS({
           if (mode === "mod") {
             return {
               div: null,
-              mod: new BN3(this.modrn(num.words[0]))
+              mod: new BN4(this.modrn(num.words[0]))
             };
           }
           return {
             div: this.divn(num.words[0]),
-            mod: new BN3(this.modrn(num.words[0]))
+            mod: new BN4(this.modrn(num.words[0]))
           };
         }
         return this._wordDiv(num, mode);
       };
-      BN3.prototype.div = function div(num) {
+      BN4.prototype.div = function div(num) {
         return this.divmod(num, "div", false).div;
       };
-      BN3.prototype.mod = function mod(num) {
+      BN4.prototype.mod = function mod(num) {
         return this.divmod(num, "mod", false).mod;
       };
-      BN3.prototype.umod = function umod(num) {
+      BN4.prototype.umod = function umod(num) {
         return this.divmod(num, "mod", true).mod;
       };
-      BN3.prototype.divRound = function divRound(num) {
+      BN4.prototype.divRound = function divRound(num) {
         var dm = this.divmod(num);
         if (dm.mod.isZero()) return dm.div;
         var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
@@ -3774,7 +3774,7 @@ var require_bn = __commonJS({
         if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
       };
-      BN3.prototype.modrn = function modrn(num) {
+      BN4.prototype.modrn = function modrn(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(num <= 67108863);
@@ -3785,10 +3785,10 @@ var require_bn = __commonJS({
         }
         return isNegNum ? -acc : acc;
       };
-      BN3.prototype.modn = function modn(num) {
+      BN4.prototype.modn = function modn(num) {
         return this.modrn(num);
       };
-      BN3.prototype.idivn = function idivn(num) {
+      BN4.prototype.idivn = function idivn(num) {
         var isNegNum = num < 0;
         if (isNegNum) num = -num;
         assert(num <= 67108863);
@@ -3801,10 +3801,10 @@ var require_bn = __commonJS({
         this._strip();
         return isNegNum ? this.ineg() : this;
       };
-      BN3.prototype.divn = function divn(num) {
+      BN4.prototype.divn = function divn(num) {
         return this.clone().idivn(num);
       };
-      BN3.prototype.egcd = function egcd(p) {
+      BN4.prototype.egcd = function egcd(p) {
         assert(p.negative === 0);
         assert(!p.isZero());
         var x = this;
@@ -3814,10 +3814,10 @@ var require_bn = __commonJS({
         } else {
           x = x.clone();
         }
-        var A = new BN3(1);
-        var B = new BN3(0);
-        var C = new BN3(0);
-        var D = new BN3(1);
+        var A = new BN4(1);
+        var B = new BN4(0);
+        var C = new BN4(0);
+        var D = new BN4(1);
         var g = 0;
         while (x.isEven() && y.isEven()) {
           x.iushrn(1);
@@ -3867,7 +3867,7 @@ var require_bn = __commonJS({
           gcd: y.iushln(g)
         };
       };
-      BN3.prototype._invmp = function _invmp(p) {
+      BN4.prototype._invmp = function _invmp(p) {
         assert(p.negative === 0);
         assert(!p.isZero());
         var a = this;
@@ -3877,8 +3877,8 @@ var require_bn = __commonJS({
         } else {
           a = a.clone();
         }
-        var x1 = new BN3(1);
-        var x2 = new BN3(0);
+        var x1 = new BN4(1);
+        var x2 = new BN4(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) ;
@@ -3920,7 +3920,7 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN3.prototype.gcd = function gcd(num) {
+      BN4.prototype.gcd = function gcd(num) {
         if (this.isZero()) return num.abs();
         if (num.isZero()) return this.abs();
         var a = this.clone();
@@ -3950,19 +3950,19 @@ var require_bn = __commonJS({
         } while (true);
         return b.iushln(shift);
       };
-      BN3.prototype.invm = function invm(num) {
+      BN4.prototype.invm = function invm(num) {
         return this.egcd(num).a.umod(num);
       };
-      BN3.prototype.isEven = function isEven() {
+      BN4.prototype.isEven = function isEven() {
         return (this.words[0] & 1) === 0;
       };
-      BN3.prototype.isOdd = function isOdd() {
+      BN4.prototype.isOdd = function isOdd() {
         return (this.words[0] & 1) === 1;
       };
-      BN3.prototype.andln = function andln(num) {
+      BN4.prototype.andln = function andln(num) {
         return this.words[0] & num;
       };
-      BN3.prototype.bincn = function bincn(bit) {
+      BN4.prototype.bincn = function bincn(bit) {
         assert(typeof bit === "number");
         var r = bit % 26;
         var s = (bit - r) / 26;
@@ -3986,10 +3986,10 @@ var require_bn = __commonJS({
         }
         return this;
       };
-      BN3.prototype.isZero = function isZero() {
+      BN4.prototype.isZero = function isZero() {
         return this.length === 1 && this.words[0] === 0;
       };
-      BN3.prototype.cmpn = function cmpn(num) {
+      BN4.prototype.cmpn = function cmpn(num) {
         var negative = num < 0;
         if (this.negative !== 0 && !negative) return -1;
         if (this.negative === 0 && negative) return 1;
@@ -4008,14 +4008,14 @@ var require_bn = __commonJS({
         if (this.negative !== 0) return -res | 0;
         return res;
       };
-      BN3.prototype.cmp = function cmp(num) {
+      BN4.prototype.cmp = function cmp(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;
       };
-      BN3.prototype.ucmp = function ucmp(num) {
+      BN4.prototype.ucmp = function ucmp(num) {
         if (this.length > num.length) return 1;
         if (this.length < num.length) return -1;
         var res = 0;
@@ -4032,112 +4032,112 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      BN3.prototype.gtn = function gtn(num) {
+      BN4.prototype.gtn = function gtn(num) {
         return this.cmpn(num) === 1;
       };
-      BN3.prototype.gt = function gt(num) {
+      BN4.prototype.gt = function gt(num) {
         return this.cmp(num) === 1;
       };
-      BN3.prototype.gten = function gten(num) {
+      BN4.prototype.gten = function gten(num) {
         return this.cmpn(num) >= 0;
       };
-      BN3.prototype.gte = function gte(num) {
+      BN4.prototype.gte = function gte(num) {
         return this.cmp(num) >= 0;
       };
-      BN3.prototype.ltn = function ltn(num) {
+      BN4.prototype.ltn = function ltn(num) {
         return this.cmpn(num) === -1;
       };
-      BN3.prototype.lt = function lt(num) {
+      BN4.prototype.lt = function lt(num) {
         return this.cmp(num) === -1;
       };
-      BN3.prototype.lten = function lten(num) {
+      BN4.prototype.lten = function lten(num) {
         return this.cmpn(num) <= 0;
       };
-      BN3.prototype.lte = function lte(num) {
+      BN4.prototype.lte = function lte(num) {
         return this.cmp(num) <= 0;
       };
-      BN3.prototype.eqn = function eqn(num) {
+      BN4.prototype.eqn = function eqn(num) {
         return this.cmpn(num) === 0;
       };
-      BN3.prototype.eq = function eq(num) {
+      BN4.prototype.eq = function eq(num) {
         return this.cmp(num) === 0;
       };
-      BN3.red = function red(num) {
+      BN4.red = function red(num) {
         return new Red(num);
       };
-      BN3.prototype.toRed = function toRed(ctx) {
+      BN4.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);
       };
-      BN3.prototype.fromRed = function fromRed() {
+      BN4.prototype.fromRed = function fromRed() {
         assert(this.red, "fromRed works only with numbers in reduction context");
         return this.red.convertFrom(this);
       };
-      BN3.prototype._forceRed = function _forceRed(ctx) {
+      BN4.prototype._forceRed = function _forceRed(ctx) {
         this.red = ctx;
         return this;
       };
-      BN3.prototype.forceRed = function forceRed(ctx) {
+      BN4.prototype.forceRed = function forceRed(ctx) {
         assert(!this.red, "Already a number in reduction context");
         return this._forceRed(ctx);
       };
-      BN3.prototype.redAdd = function redAdd(num) {
+      BN4.prototype.redAdd = function redAdd(num) {
         assert(this.red, "redAdd works only with red numbers");
         return this.red.add(this, num);
       };
-      BN3.prototype.redIAdd = function redIAdd(num) {
+      BN4.prototype.redIAdd = function redIAdd(num) {
         assert(this.red, "redIAdd works only with red numbers");
         return this.red.iadd(this, num);
       };
-      BN3.prototype.redSub = function redSub(num) {
+      BN4.prototype.redSub = function redSub(num) {
         assert(this.red, "redSub works only with red numbers");
         return this.red.sub(this, num);
       };
-      BN3.prototype.redISub = function redISub(num) {
+      BN4.prototype.redISub = function redISub(num) {
         assert(this.red, "redISub works only with red numbers");
         return this.red.isub(this, num);
       };
-      BN3.prototype.redShl = function redShl(num) {
+      BN4.prototype.redShl = function redShl(num) {
         assert(this.red, "redShl works only with red numbers");
         return this.red.shl(this, num);
       };
-      BN3.prototype.redMul = function redMul(num) {
+      BN4.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);
       };
-      BN3.prototype.redIMul = function redIMul(num) {
+      BN4.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);
       };
-      BN3.prototype.redSqr = function redSqr() {
+      BN4.prototype.redSqr = function redSqr() {
         assert(this.red, "redSqr works only with red numbers");
         this.red._verify1(this);
         return this.red.sqr(this);
       };
-      BN3.prototype.redISqr = function redISqr() {
+      BN4.prototype.redISqr = function redISqr() {
         assert(this.red, "redISqr works only with red numbers");
         this.red._verify1(this);
         return this.red.isqr(this);
       };
-      BN3.prototype.redSqrt = function redSqrt() {
+      BN4.prototype.redSqrt = function redSqrt() {
         assert(this.red, "redSqrt works only with red numbers");
         this.red._verify1(this);
         return this.red.sqrt(this);
       };
-      BN3.prototype.redInvm = function redInvm() {
+      BN4.prototype.redInvm = function redInvm() {
         assert(this.red, "redInvm works only with red numbers");
         this.red._verify1(this);
         return this.red.invm(this);
       };
-      BN3.prototype.redNeg = function redNeg() {
+      BN4.prototype.redNeg = function redNeg() {
         assert(this.red, "redNeg works only with red numbers");
         this.red._verify1(this);
         return this.red.neg(this);
       };
-      BN3.prototype.redPow = function redPow(num) {
+      BN4.prototype.redPow = function redPow(num) {
         assert(this.red && !num.red, "redPow(normalNum)");
         this.red._verify1(this);
         return this.red.pow(this, num);
@@ -4150,13 +4150,13 @@ var require_bn = __commonJS({
       };
       function MPrime(name, p) {
         this.name = name;
-        this.p = new BN3(p, 16);
+        this.p = new BN4(p, 16);
         this.n = this.p.bitLength();
-        this.k = new BN3(1).iushln(this.n).isub(this.p);
+        this.k = new BN4(1).iushln(this.n).isub(this.p);
         this.tmp = this._tmp();
       }
       MPrime.prototype._tmp = function _tmp() {
-        var tmp = new BN3(null);
+        var tmp = new BN4(null);
         tmp.words = new Array(Math.ceil(this.n / 13));
         return tmp;
       };
@@ -4282,7 +4282,7 @@ var require_bn = __commonJS({
         }
         return num;
       };
-      BN3._prime = function prime(name) {
+      BN4._prime = function prime(name) {
         if (primes[name]) return primes[name];
         var prime2;
         if (name === "k256") {
@@ -4301,7 +4301,7 @@ var require_bn = __commonJS({
       };
       function Red(m) {
         if (typeof m === "string") {
-          var prime = BN3._prime(m);
+          var prime = BN4._prime(m);
           this.m = prime.p;
           this.prime = prime;
         } else {
@@ -4387,7 +4387,7 @@ var require_bn = __commonJS({
         var mod3 = this.m.andln(3);
         assert(mod3 % 2 === 1);
         if (mod3 === 3) {
-          var pow = this.m.add(new BN3(1)).iushrn(2);
+          var pow = this.m.add(new BN4(1)).iushrn(2);
           return this.pow(a, pow);
         }
         var q = this.m.subn(1);
@@ -4397,11 +4397,11 @@ var require_bn = __commonJS({
           q.iushrn(1);
         }
         assert(!q.isZero());
-        var one = new BN3(1).toRed(this);
+        var one = new BN4(1).toRed(this);
         var nOne = one.redNeg();
         var lpow = this.m.subn(1).iushrn(1);
         var z = this.m.bitLength();
-        z = new BN3(2 * z * z).toRed(this);
+        z = new BN4(2 * z * z).toRed(this);
         while (this.pow(z, lpow).cmp(nOne) !== 0) {
           z.redIAdd(nOne);
         }
@@ -4415,7 +4415,7 @@ var require_bn = __commonJS({
             tmp = tmp.redSqr();
           }
           assert(i < m);
-          var b = this.pow(c, new BN3(1).iushln(m - i - 1));
+          var b = this.pow(c, new BN4(1).iushln(m - i - 1));
           r = r.redMul(b);
           c = b.redSqr();
           t = t.redMul(c);
@@ -4433,11 +4433,11 @@ var require_bn = __commonJS({
         }
       };
       Red.prototype.pow = function pow(a, num) {
-        if (num.isZero()) return new BN3(1).toRed(this);
+        if (num.isZero()) return new BN4(1).toRed(this);
         if (num.cmpn(1) === 0) return a.clone();
         var windowSize = 4;
         var wnd = new Array(1 << windowSize);
-        wnd[0] = new BN3(1).toRed(this);
+        wnd[0] = new BN4(1).toRed(this);
         wnd[1] = a;
         for (var i = 2; i < wnd.length; i++) {
           wnd[i] = this.mul(wnd[i - 1], a);
@@ -4481,7 +4481,7 @@ var require_bn = __commonJS({
         res.red = null;
         return res;
       };
-      BN3.mont = function mont(num) {
+      BN4.mont = function mont(num) {
         return new Mont(num);
       };
       function Mont(m) {
@@ -4490,7 +4490,7 @@ var require_bn = __commonJS({
         if (this.shift % 26 !== 0) {
           this.shift += 26 - this.shift % 26;
         }
-        this.r = new BN3(1).iushln(this.shift);
+        this.r = new BN4(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);
@@ -4524,7 +4524,7 @@ var require_bn = __commonJS({
         return res._forceRed(this);
       };
       Mont.prototype.mul = function mul(a, b) {
-        if (a.isZero() || b.isZero()) return new BN3(0)._forceRed(this);
+        if (a.isZero() || b.isZero()) return new BN4(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);
@@ -4546,144 +4546,71 @@ var require_bn = __commonJS({
 
 // src/client.ts
 var import_bn = __toESM(require_bn());
-var JPOOL_STAKE_POOL = new PublicKey("CtMyWsrUtAwXWiGr9WjHT5fC3p3fgV8cyGpLTo2LJzG1");
-var Seeds = /* @__PURE__ */ ((Seeds2) => {
-  Seeds2["GlobalState"] = "global_state";
-  Seeds2["BondState"] = "bond_state";
-  Seeds2["ValidatorBond"] = "validator_bond";
-  Seeds2["StandardBond"] = "standard";
-  Seeds2["CrowdFundingBond"] = "crowdfunding";
-  return Seeds2;
-})(Seeds || {});
+
+// src/constants.ts
+var GLOBAL_STATE_SEED = "global_state";
+var BOND_STATE_SEED = "bond_state";
+var VALIDATOR_BOND_SEED = "validator_bond";
+var STANDARD_BOND_SEED = "standard";
+var CROWDFUNDING_BOND_SEED = "crowdfunding";
 var ENV_PROGRAM_ID = {
   // [BondClientEnv.DEV]: new PublicKey('...'),
 };
 
 // src/types/index.ts
-var bondTypeToSeed = {
-  standard: "standard" /* StandardBond */,
-  crowdfunding: "crowdfunding" /* CrowdFundingBond */
-};
-var BondTypeVariant = {
-  Standard: { standard: {} },
-  Crowdfunding: { crowdfunding: {} }
-};
-var BondStateStatusVariant = {
-  Active: { active: {} },
-  Disabled: { disabled: {} }
-};
+var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
+  SessionStatus2[SessionStatus2["Live"] = 0] = "Live";
+  SessionStatus2[SessionStatus2["Finished"] = 1] = "Finished";
+  return SessionStatus2;
+})(SessionStatus || {});
+var BondType = /* @__PURE__ */ ((BondType2) => {
+  BondType2["Standard"] = "standard";
+  BondType2["Crowdfunding"] = "crowdfunding";
+  return BondType2;
+})(BondType || {});
 var BondTransactionType = /* @__PURE__ */ ((BondTransactionType2) => {
   BondTransactionType2["Deposit"] = "deposit";
   BondTransactionType2["Withdrawal"] = "withdrawal";
   BondTransactionType2["Compensation"] = "compensation";
   return BondTransactionType2;
 })(BondTransactionType || {});
-var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
-  SessionStatus2[SessionStatus2["Live"] = 0] = "Live";
-  SessionStatus2[SessionStatus2["Finished"] = 1] = "Finished";
-  return SessionStatus2;
-})(SessionStatus || {});
-
-// src/utils/enum.ts
-function getVariant(v) {
-  const key = Object.keys(v)[0];
-  return [key, v[key]];
-}
-function variantArgs(payload) {
-  if (Array.isArray(payload)) {
-    return payload;
-  }
-  if (payload && typeof payload === "object") {
-    const numericKeys = Object.keys(payload).filter((k) => String(+k) === k);
-    if (numericKeys.length) {
-      return numericKeys.sort((a, b) => +a - +b).map((k) => payload[k]);
-    }
-    return [payload];
-  }
-  return [payload];
-}
-function matchVariant(v, handlers) {
-  const [k, data] = getVariant(v);
-  const h = handlers[k];
-  if (!h) {
-    throw new Error(`Unhandled variant: ${k}`);
-  }
-  return h(...variantArgs(data));
-}
-function variantKey(v) {
-  return Object.keys(v)[0];
-}
-function sameVariant(a, b) {
-  return variantKey(a) === variantKey(b);
-}
-
-// src/utils/wallet.ts
-function isVersionedTransaction(tx) {
-  return "version" in tx;
-}
-var NodeWallet = class {
-  constructor(payer) {
-    this.payer = payer;
-  }
-  async signTransaction(tx) {
-    if (isVersionedTransaction(tx)) {
-      tx.sign([this.payer]);
-    } else {
-      tx.partialSign(this.payer);
-    }
-    return tx;
-  }
-  async signAllTransactions(txs) {
-    return txs.map((t) => {
-      if (isVersionedTransaction(t)) {
-        t.sign([this.payer]);
-      } else {
-        t.partialSign(this.payer);
-      }
-      return t;
-    });
-  }
-  get publicKey() {
-    return this.payer.publicKey;
-  }
-};
-
-// src/utils/web3.ts
-var SLOTS_PER_EPOCH_MAINNET = 432e3;
-var SLOTS_PER_EPOCH_DEVNET = 4e5;
-function slotToEpoch(slot, cluster) {
-  const slotsPerEpoch = cluster === "mainnet-beta" ? SLOTS_PER_EPOCH_MAINNET : SLOTS_PER_EPOCH_DEVNET;
-  return Math.floor(slot / slotsPerEpoch);
-}
 
 // src/history.ts
 var { bs58 } = utils.bytes;
 var HistoryManager = class {
-  program;
-  connection;
-  programId;
+  constructor(client) {
+    this.client = client;
+  }
+  // Cache of instruction discriminators
   discCache = /* @__PURE__ */ new Map();
-  constructor(program, connection, programId) {
-    this.program = program;
-    this.connection = connection;
-    this.programId = programId;
+  get program() {
+    return this.client.program;
+  }
+  get programId() {
+    return this.client.programId;
+  }
+  get connection() {
+    return this.client.provider.connection;
+  }
+  debug(...args) {
+    this.client.debug(...args);
   }
-  async getHistory(bondType, vote, pdaDeriver, options) {
-    const cluster = options?.cluster || "mainnet-beta";
-    const [validatorBondAccount] = pdaDeriver(bondType, vote);
+  async getHistory(bondType, bondName, vote, opts) {
+    const [validatorBondAccount] = this.client.pda.validatorBond(bondType, bondName, vote);
+    this.debug(`Fetching history for validator bond account: ${validatorBondAccount.toBase58()}`);
     const signatures = await this.fetchSignaturesForAddress(validatorBondAccount, {
-      limit: options?.limit,
-      before: options?.before,
-      until: options?.until
+      limit: opts?.limit,
+      before: opts?.before,
+      until: opts?.until
     });
     if (!signatures.length) {
       return [];
     }
-    const sigStrs = signatures.map((s) => s.signature);
-    const parsed = await this.fetchParsedTransactions(sigStrs);
+    const sigs = signatures.map((s) => s.signature);
+    const parsed = await this.fetchParsedTransactions(sigs);
     const txBySig = /* @__PURE__ */ new Map();
-    for (let i = 0; i < sigStrs.length; i++) {
-      const want = sigStrs[i];
+    for (let i = 0; i < sigs.length; i++) {
+      const want = sigs[i];
       const tx = parsed[i] ?? null;
       if (tx?.transaction?.signatures?.[0] && tx.transaction.signatures[0] !== want) {
         const found = parsed.find((t) => t?.transaction?.signatures?.[0] === want) ?? null;
@@ -4718,7 +4645,7 @@ var HistoryManager = class {
         history.push({
           signature: sig,
           slot,
-          epoch: slotToEpoch(slot, cluster),
+          epoch: slotToEpoch(slot, opts?.cluster),
           type,
           amount
         });
@@ -4731,7 +4658,8 @@ var HistoryManager = class {
       limit: options?.limit || 1e3,
       before: options?.before,
       until: options?.until
-    });
+    }, "confirmed");
+    console.log(sigs);
     return sigs.filter((s) => !s.err);
   }
   async fetchParsedTransactions(sigs, batchSize = 100) {
@@ -4739,6 +4667,7 @@ var HistoryManager = class {
     for (let i = 0; i < sigs.length; i += batchSize) {
       const batch = sigs.slice(i, i + batchSize);
       const txs = await this.connection.getParsedTransactions(batch, {
+        commitment: "confirmed",
         maxSupportedTransactionVersion: 0
       });
       all.push(...txs);
@@ -4798,6 +4727,11 @@ var HistoryManager = class {
     }
   }
 };
+function slotToEpoch(slot, cluster) {
+  const isMainnet = !cluster || cluster === "mainnet-beta";
+  const slotsPerEpoch = isMainnet ? 432e3 : 4e5;
+  return Math.floor(slot / slotsPerEpoch);
+}
 
 // src/idl/jbond.json
 var jbond_default = {
@@ -6387,8 +6321,102 @@ var jbond_default = {
   ]
 };
 
+// src/utils/enum.ts
+function getVariant(v) {
+  const key = Object.keys(v)[0];
+  return [key, v[key]];
+}
+function variantArgs(payload) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+  if (payload && typeof payload === "object") {
+    const numericKeys = Object.keys(payload).filter((k) => String(+k) === k);
+    if (numericKeys.length) {
+      return numericKeys.sort((a, b) => +a - +b).map((k) => payload[k]);
+    }
+    return [payload];
+  }
+  return [payload];
+}
+function matchVariant(v, handlers) {
+  const [k, data] = getVariant(v);
+  const h = handlers[k];
+  if (!h) {
+    throw new Error(`Unhandled variant: ${k}`);
+  }
+  return h(...variantArgs(data));
+}
+function variantKey(v) {
+  return Object.keys(v)[0];
+}
+function sameVariant(a, b) {
+  return variantKey(a) === variantKey(b);
+}
+function toAnchor(key, payload) {
+  return { [key]: {} };
+}
+function fromAnchor(variant) {
+  return variantKey(variant);
+}
+function bondTypeToAnchor(type, payload) {
+  return toAnchor(type);
+}
+function anchorToBondType(variant) {
+  return fromAnchor(variant);
+}
+
+// src/utils/wallet.ts
+function isVersionedTransaction(tx) {
+  return "version" in tx;
+}
+var NodeWallet = class {
+  constructor(payer) {
+    this.payer = payer;
+  }
+  async signTransaction(tx) {
+    if (isVersionedTransaction(tx)) {
+      tx.sign([this.payer]);
+    } else {
+      tx.partialSign(this.payer);
+    }
+    return tx;
+  }
+  async signAllTransactions(txs) {
+    return txs.map((t) => {
+      if (isVersionedTransaction(t)) {
+        t.sign([this.payer]);
+      } else {
+        t.partialSign(this.payer);
+      }
+      return t;
+    });
+  }
+  get publicKey() {
+    return this.payer.publicKey;
+  }
+};
+var SOL_DECIMALS = Math.log10(LAMPORTS_PER_SOL);
+function solToLamports(amount) {
+  if (Number.isNaN(amount)) {
+    return new BN(0);
+  }
+  return new BN(Number(amount).toFixed(SOL_DECIMALS).replace(".", ""));
+}
+
+// src/utils/index.ts
+function getBondTypeSeed(type) {
+  switch (type) {
+    case "standard" /* Standard */:
+      return STANDARD_BOND_SEED;
+    case "crowdfunding" /* Crowdfunding */:
+      return CROWDFUNDING_BOND_SEED;
+    default:
+      throw new Error(`Unknown bond type: ${type}`);
+  }
+}
+
 // src/client.ts
-var { bs58: bs582 } = utils.bytes;
 var BondClientEnv = /* @__PURE__ */ ((BondClientEnv2) => {
   BondClientEnv2["DEV"] = "dev";
   BondClientEnv2["STAGE"] = "stage";
@@ -6400,11 +6428,12 @@ var JBondClient = class _JBondClient {
     this.provider = provider;
     this.options = options ?? {};
     this.program = new Program(jbond_default, this.provider);
-    this.history = new HistoryManager(this.program, this.provider.connection, this.program.programId);
   }
   options;
   program;
-  history;
+  get history() {
+    return new HistoryManager(this);
+  }
   /**
    * Creates an instance of `JBondClient` using a provided connection and wallet.
    */
@@ -6440,167 +6469,151 @@ var JBondClient = class _JBondClient {
    * Set the environment.
    */
   env(env) {
-    return this.configureEnv("programId", ENV_PROGRAM_ID[env]);
+    return this.configure("programId", ENV_PROGRAM_ID[env]);
   }
   /**
    * Configure a specific option.
    */
-  configureEnv(key, val) {
+  configure(key, val) {
     this.options[key] = val;
     return this;
   }
-  getBondTypeSeed(bondType) {
-    const [k] = getVariant(bondType);
-    return bondTypeToSeed[k];
+  /**
+   * Debug logging
+   * @param args
+   */
+  debug(...args) {
+    if (this.options.debug) {
+      console.log(`%c[JBondClient]`, "color: #009999;", ...args);
+    }
   }
   /**
    * Program Derived Addresses (PDAs)
    */
   pda = {
-    globalState: () => {
-      return PublicKey.findProgramAddressSync(
-        [Buffer.from("global_state" /* GlobalState */)],
-        this.programId
-      );
-    },
+    globalState: () => PublicKey.findProgramAddressSync(
+      [Buffer.from(GLOBAL_STATE_SEED)],
+      this.programId
+    ),
     bondState: (bondType, bondName) => {
-      const seed = this.getBondTypeSeed(bondType);
       return PublicKey.findProgramAddressSync(
-        [Buffer.from("bond_state" /* BondState */), Buffer.from(seed), Buffer.from(bondName)],
+        [Buffer.from(BOND_STATE_SEED), Buffer.from(getBondTypeSeed(bondType)), Buffer.from(bondName)],
         this.programId
       );
     },
-    // Derives a validator bond PDA based on the bond type and vote account
     validatorBond: (bondType, bondName, vote) => {
       const [bondState] = this.pda.bondState(bondType, bondName);
       return PublicKey.findProgramAddressSync(
-        [
-          Buffer.from("validator_bond" /* ValidatorBond */),
-          bondState.toBuffer(),
-          new PublicKey(vote).toBuffer()
-        ],
+        [Buffer.from(VALIDATOR_BOND_SEED), bondState.toBuffer(), new PublicKey(vote).toBuffer()],
         this.programId
       );
     }
   };
+  /**
+   * Initialize global state
+   */
   async globalInitialize(props) {
-    const ix = await this.buildBondGlobalStateInitializeIx(props);
+    const ix = await this.getGlobalInitializeIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Initialize the program
-   * Default authority is the provider's wallet
    */
   async bondInitialize(props) {
-    console.log("Building bond initialize instruction with props:", props);
-    const ix = await this.buildBondInitializeIx(props);
+    const ix = await this.getBondInitializeIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Register a new validator
-   * Default creator is the provider's wallet
    */
   async registerValidator(props) {
-    const ix = await this.buildRegisterIx(props);
+    const ix = await this.getRegisterValidatorIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Top up collateral
-   * Default payer is the provider's wallet
    */
   async topUpCollateral(props) {
-    const ixs = await this.buildTopUpIXs(props);
+    const ixs = await this.getTopUpIxs(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(...ixs));
   }
   /**
    * Withdraw collateral
-   * Default withdrawal authority is the provider's wallet
-   * Default destination is the provider's wallet
-   * @return Transaction signature
    */
   async withdrawCollateral(props) {
-    const ix = await this.buildWithdrawIx(props);
+    const ix = await this.getWithdrawIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Claim compensation
-   * Default authority is the provider's wallet
-   * @return Transaction signature
    */
   async claimCompensation(props) {
-    const ix = await this.buildClaimIx(props);
+    const ix = await this.getClaimIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Update global configuration for the program
-   * Default authority is the provider's wallet
-   * Only the current authority can call this
-   * @return Transaction signature
    */
   async globalConfigure(props) {
-    const ix = await this.buildGlobalConfigureInstruction(props);
+    const ix = await this.getGlobalConfigureIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Update global configuration for the program
-   * Default authority is the provider's wallet
-   * Only the current authority can call this
-   * @return Transaction signature
    */
   async bondConfigure(props) {
-    const ix = await this.buildConfigureIx(props);
+    const ix = await this.getBondConfigureIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
   /**
    * Set withdrawal authority for validator bond
-   * Only the validator identity can call this
-   * Default identity is the provider's wallet
-   * @return Transaction signature
    */
   async setWithdrawAuthority(props) {
-    const ix = await this.buildSetWithdrawAuthorityIx(props);
+    const ix = await this.getSetWithdrawAuthorityIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
+  /**
+   * Start crowdfunding bond session
+   */
   async bondStart(props) {
-    const ix = await this.buildBondStartIx(props);
+    const ix = await this.getBondSessionStartIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
+  /**
+   * Finish crowdfunding bond session
+   */
   async bondFinish(props) {
-    const ix = await this.buildBondFinishIx(props);
+    const ix = await this.getBondSessionFinishIx(props);
     return this.provider.sendAndConfirm?.(new Transaction().add(ix));
   }
-  async buildBondGlobalStateInitializeIx(props) {
+  /**
+   * Build global state initialize instruction
+   */
+  async getGlobalInitializeIx(props) {
     const [globalState] = this.pda.globalState();
     const authority = props.authority ?? this.provider.wallet?.publicKey;
-    return this.program.methods.globalInitialize().accountsPartial({
-      globalState,
-      authority
-    }).instruction();
+    return this.program.methods.globalInitialize().accountsPartial({ globalState, authority }).instruction();
   }
   /**
    * Build configure instruction
    */
-  async buildGlobalConfigureInstruction(props) {
+  async getGlobalConfigureIx(props) {
     const [globalState] = this.pda.globalState();
     const authority = props.authority ?? this.provider.wallet?.publicKey;
     return this.program.methods.globalConfigure({
       newAuthority: props.newAuthority ?? null
-    }).accountsStrict({
-      globalState,
-      authority
-    }).instruction();
+    }).accountsStrict({ globalState, authority }).instruction();
   }
   /**
-   * Build initialize instruction
+   * Build bond initialize instruction
    */
-  async buildBondInitializeIx(props) {
+  async getBondInitializeIx(props) {
     const [bondState] = this.pda.bondState(props.bondType, props.name);
+    const authority = props.authority ?? this.provider.wallet?.publicKey;
     const accounts = {
       bondState,
-      authority: props.authority ?? this.program.provider.wallet?.publicKey,
+      authority,
       reserve: props.reserve,
-      systemProgram: SystemProgram.programId,
-      tokenProgram: TOKEN_PROGRAM_ID,
       reserveTokenAccount: null,
       mint: null
     };
@@ -6614,42 +6627,45 @@ var JBondClient = class _JBondClient {
     });
     return this.program.methods.bondInitialize({
       name: props.name,
-      bondType: props.bondType,
+      bondType: bondTypeToAnchor(props.bondType),
       reserve: props.reserve,
       collateralType: props.collateralType
-    }).accountsPartial(
-      accounts
-    ).instruction();
+    }).accountsPartial(accounts).instruction();
   }
-  async buildConfigureIx(props) {
+  /**
+   * Build bond configure instruction
+   */
+  async getBondConfigureIx(props) {
     const [bondState] = this.pda.bondState(props.bondType, props.name);
+    const authority = props.authority ?? this.provider.wallet?.publicKey;
     return this.program.methods.bondConfigure({
-      status: props.bondStateStatus ?? null,
+      status: props.status ?? null,
       newReserve: props.newReserve ?? null,
       newAuthority: props.newAuthority ?? null
-    }).accountsStrict({
-      bondState,
-      authority: props.authority ?? this.program.provider.wallet?.publicKey
-    }).instruction();
+    }).accountsStrict({ bondState, authority }).instruction();
   }
-  async buildRegisterIx(props) {
+  /**
+   * Build register validator instruction
+   */
+  async getRegisterValidatorIx(props) {
     const { bondType, voteAccount, identity, name } = props;
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
-    const creator = props.creator ?? this.program.provider.wallet?.publicKey;
+    const creator = props.creator ?? this.provider.wallet?.publicKey;
     if (!creator) {
       throw new Error("Missing creator");
     }
-    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
+    let collateralType = props.collateralType;
+    if (!collateralType) {
+      const bondState2 = await this.getBondState(bondType, name);
+      collateralType = bondState2.collateralType;
+    }
     const accounts = {
       bondState,
       validatorBond,
       identity,
       voteAccount,
       creator,
-      systemProgram: SystemProgram.programId,
-      tokenProgram: TOKEN_PROGRAM_ID,
-      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
       bondTokenAccount: null,
       mint: null
     };
@@ -6658,42 +6674,49 @@ var JBondClient = class _JBondClient {
       },
       token: (mint) => {
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-        Object.assign(accounts, { mint, bondTokenAccount: accounts.bondTokenAccount });
+        accounts.mint = mint;
       }
     });
-    return this.program.methods.bondRegister(bondType, name).accountsPartial(accounts).instruction();
+    return this.program.methods.bondRegister(bondTypeToAnchor(bondType), name).accountsPartial(accounts).instruction();
   }
-  async buildTopUpIXs(props) {
-    const { bondType, voteAccount, collateral, name } = props;
-    const payer = props.payer ?? this.program.provider.wallet?.publicKey;
+  /**
+   * Build top up collateral instructions
+   */
+  async getTopUpIxs(props) {
+    const { bondType, voteAccount, amount, name } = props;
+    const payer = props.payer ?? this.provider.wallet?.publicKey;
     if (!payer) {
       throw new Error("Missing payer");
     }
-    const instructions = [];
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
-    console.log("Top up collateral for bond:", { bondState: bondState.toBase58(), validatorBond: validatorBond.toBase58() });
-    const bond = await this.getValidatorBond(props.bondType, props.name, props.voteAccount);
-    if (!bond) {
-      instructions.push(await this.buildRegisterIx({
-        bondType: props.bondType,
-        name: props.name,
-        voteAccount: props.voteAccount,
-        identity: props.identity,
-        creator: props.payer
-      }));
+    let collateralType = props.collateralType;
+    if (!collateralType) {
+      const bondState2 = await this.getBondState(bondType, name);
+      collateralType = bondState2.collateralType;
+    }
+    const instructions = [];
+    try {
+      await this.getValidatorBond(props.bondType, props.name, props.voteAccount);
+    } catch {
+      instructions.push(
+        await this.getRegisterValidatorIx({
+          bondType: props.bondType,
+          name: props.name,
+          voteAccount: props.voteAccount,
+          identity: props.identity,
+          creator: props.payer,
+          collateralType
+        })
+      );
     }
-    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
       payer,
-      systemProgram: SystemProgram.programId,
       payerTokenAccount: null,
       bondTokenAccount: null,
       stakeAccount: null,
-      tokenProgram: null,
-      associatedTokenProgram: null,
       stakeProgram: null
     };
     matchVariant(collateralType, {
@@ -6702,35 +6725,38 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.payerTokenAccount = getAssociatedTokenAddressSync(mint, payer);
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-        accounts.tokenProgram = TOKEN_PROGRAM_ID;
-        accounts.associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID;
       }
     });
     instructions.push(
-      await this.program.methods.bondTopUp(this.lamports(collateral.amount)).accountsPartial(accounts).instruction()
+      await this.program.methods.bondTopUp(solToLamports(amount)).accountsPartial(accounts).instruction()
     );
     return instructions;
   }
-  async buildWithdrawIx(props) {
-    const { bondType, voteAccount, withdraw, name } = props;
+  /**
+   * Build withdraw collateral instruction
+   */
+  async getWithdrawIx(props) {
+    const { bondType, voteAccount, amount, name } = props;
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, voteAccount);
-    const payer = this.program.provider.wallet?.publicKey;
+    const payer = this.provider.wallet?.publicKey;
     const destination = props.destination ?? payer;
     if (!payer || !destination) {
       throw new Error("Missing payer/destination");
     }
-    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
+    let collateralType = props.collateralType;
+    if (!collateralType) {
+      const bondState2 = await this.getBondState(bondType, name);
+      collateralType = bondState2.collateralType;
+    }
     const accounts = {
       bondState,
       validatorBond,
-      withdrawalAuthority: props.withdrawalAuthority ?? payer,
       destination,
+      withdrawalAuthority: props.withdrawalAuthority ?? payer,
       destinationTokenAccount: null,
       bondTokenAccount: null,
       stakeAccount: null,
-      systemProgram: SystemProgram.programId,
-      tokenProgram: null,
       stakeProgram: null
     };
     matchVariant(collateralType, {
@@ -6739,31 +6765,34 @@ var JBondClient = class _JBondClient {
       token: (mint) => {
         accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, destination, true);
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
-        accounts.tokenProgram = TOKEN_PROGRAM_ID;
       }
     });
-    return this.program.methods.bondWithdraw(this.lamports(withdraw.amount)).accountsPartial(accounts).instruction();
+    return this.program.methods.bondWithdraw(solToLamports(amount)).accountsPartial(accounts).instruction();
   }
-  async buildClaimIx(props) {
-    const { bondType, name } = props;
+  /**
+   * Build claim instruction
+   */
+  async getClaimIx(props) {
+    const { bondType, name, amount } = props;
     const [bondState] = this.pda.bondState(bondType, name);
     const [validatorBond] = this.pda.validatorBond(bondType, name, props.voteAccount);
-    const reserve = props.reserve ?? (await this.getBondState(bondType, name)).bondState.reserve;
-    const authority = props.authority ?? this.program.provider.wallet?.publicKey;
-    if (!reserve) {
-      throw new Error("Reserve not set");
+    const authority = props.authority ?? this.provider.wallet?.publicKey;
+    let reserve = props.reserve;
+    let collateralType = props.collateralType;
+    if (!collateralType || !reserve) {
+      const bondState2 = await this.getBondState(bondType, name);
+      collateralType = collateralType ?? bondState2.collateralType;
+      reserve = reserve ?? bondState2.reserve;
     }
-    const collateralType = (await this.getBondState(bondType, name)).bondState.collateralType;
     const accounts = {
       bondState,
       validatorBond,
       reserve,
-      reserveTokenAccount: null,
       authority,
+      destinationTokenAccount: null,
       bondTokenAccount: null,
+      reserveTokenAccount: null,
       stakeAccount: null,
-      systemProgram: SystemProgram.programId,
-      tokenProgram: null,
       stakeProgram: null
     };
     matchVariant(collateralType, {
@@ -6773,161 +6802,90 @@ var JBondClient = class _JBondClient {
         accounts.destinationTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
         accounts.bondTokenAccount = getAssociatedTokenAddressSync(mint, validatorBond, true);
         accounts.reserveTokenAccount = getAssociatedTokenAddressSync(mint, reserve, true);
-        accounts.tokenProgram = TOKEN_PROGRAM_ID;
       }
     });
-    return this.program.methods.bondClaim(this.lamports(props.claim.amount)).accountsPartial(
-      accounts
-    ).instruction();
+    return this.program.methods.bondClaim(solToLamports(amount)).accountsPartial(accounts).instruction();
   }
-  async buildSetWithdrawAuthorityIx(props) {
+  /**
+   * Build set withdraw authority instruction
+   */
+  async getSetWithdrawAuthorityIx(props) {
     const [validatorBond] = this.pda.validatorBond(props.bondType, props.name, props.voteAccount);
+    const identity = props.identity ?? this.provider.wallet?.publicKey;
     return this.program.methods.bondSetWithdrawAuthority().accountsPartial({
       validatorBond,
-      identity: props.identity ?? this.program.provider.wallet?.publicKey,
+      identity,
       newWithdrawAuthority: props.newWithdrawAuthority ?? null
     }).instruction();
   }
-  async buildBondFinishIx(props) {
-    const [bondState] = this.pda.bondState(props.bondType, props.name);
-    return this.program.methods.sessionFinish().accountsPartial({
-      bondState,
-      authority: this.program.provider.wallet?.publicKey
-    }).instruction();
-  }
-  async migrateBond(props) {
-    const ix = await this.buildBondMigrateIx(props);
-    return this.provider.sendAndConfirm?.(new Transaction().add(ix));
-  }
-  async buildBondMigrateIx(props) {
-    const [bondState] = this.pda.bondState(props.bondType, props.name);
-    const [legacyValidatorBond] = PublicKey.findProgramAddressSync(
-      [
-        Buffer.from("validator_bond"),
-        new PublicKey(props.voteAccount).toBuffer()
-      ],
-      this.programId
-    );
-    const [validatorBond] = this.pda.validatorBond(props.bondType, props.name, props.voteAccount);
-    return this.program.methods.migrateBond().accountsPartial({
-      bondState,
-      legacyValidatorBond,
-      legacyVoteAccount: new PublicKey(props.voteAccount),
-      validatorBond,
-      creator: this.program.provider.wallet?.publicKey
-    }).instruction();
-  }
-  async buildBondStartIx(props) {
-    const [bondState] = this.pda.bondState(props.bondType, props.name);
-    return this.program.methods.sessionStart(new import_bn.BN(props.duration_secs)).accountsPartial({
-      bondState,
-      authority: this.program.provider.wallet?.publicKey
-    }).instruction();
-  }
   /**
-   * Fetch global state or throw if not found
+   * Build finish crowdfunding session instruction
    */
-  async getGlobalState() {
-    const [globalState] = this.pda.globalState();
-    return await this.program.account.globalState.fetch(globalState);
+  async getBondSessionFinishIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    const authority = this.provider.wallet?.publicKey;
+    return this.program.methods.sessionFinish().accountsPartial({ bondState, authority }).instruction();
   }
   /**
-   * Fetch bond state with stats
-   * @param bondType - Type of the bond
-   * @param bondName - Name of the bond
-   * @param withStats
+   * Build start crowdfunding session instruction
    */
-  async getBondState(bondType, bondName, withStats = false) {
-    const bondState = await this.program.account.bondState.fetch(this.pda.bondState(bondType, bondName)[0]);
-    return {
-      bondState,
-      stateStats: withStats ? await this.getBondStateStats(bondState) : null
-    };
+  async getBondSessionStartIx(props) {
+    const [bondState] = this.pda.bondState(props.bondType, props.name);
+    const authority = this.provider.wallet?.publicKey;
+    return this.program.methods.sessionStart(new import_bn.BN(props.duration)).accountsPartial({ bondState, authority }).instruction();
   }
   /**
    * Get all bond states with total collected collateral
    */
   async getAllBondStates(bondType, sessionStatus) {
-    const bondStates = [];
-    const bondStateAccounts = await this.program.account.bondState.all();
-    for (const { publicKey, account: state } of bondStateAccounts) {
-      if (!sameVariant(state.bondType, bondType)) {
+    const result = [];
+    const accounts = await this.program.account.bondState.all();
+    for (const { publicKey, account } of accounts) {
+      if (!sameVariant(account.bondType, bondTypeToAnchor(bondType))) {
         continue;
       }
-      if (sessionStatus !== void 0 && this.getBondStateSessionStatus(state) !== sessionStatus) {
+      if (sessionStatus !== void 0 && this.getBondStateSessionStatus(account) !== sessionStatus) {
         continue;
       }
-      const bondStateStats = await this.getBondStateStats(state);
-      bondStates.push(
-        {
-          publicKey,
-          bondState: state,
-          stateStats: bondStateStats
-        }
-      );
+      const stateStats = await this.getBondStateStats(account);
+      result.push({ publicKey, bondState: account, stateStats });
     }
-    return bondStates;
+    return result;
   }
   /**
-   * Get session status for bond state
+   * Fetch global state or throw if not found
    */
-  getBondStateSessionStatus(bondState) {
-    const now = Math.floor(Date.now() / 1e3);
-    if (bondState.sessionFinishTs.toNumber() > now) {
-      return 0 /* Live */;
-    } else {
-      return 1 /* Finished */;
-    }
+  async getGlobalState() {
+    const [publicKey] = this.pda.globalState();
+    this.debug(`Fetching global state ${publicKey}...`);
+    const data = await this.program.account.globalState.fetch(publicKey);
+    return { publicKey, ...data };
   }
   /**
-   * Get all validator bonds for a given bond state
+   * Fetch bond state with stats
    */
-  async getValidatorBondsByState(bondType, bondName) {
-    const validatorBonds = [];
-    const bondStatePda = this.pda.bondState(bondType, bondName)[0];
-    const validatorBondAccounts = await this.program.account.validatorBond.all([
-      {
-        memcmp: {
-          offset: 8,
-          bytes: bondStatePda.toBase58()
-        }
-      }
-    ]);
-    for (const { account: vb } of validatorBondAccounts) {
-      validatorBonds.push(vb);
-    }
-    return validatorBonds;
+  async getBondState(bondType, bondName) {
+    const [publicKey] = this.pda.bondState(bondType, bondName);
+    this.debug(`Fetching bond state ${publicKey}...`);
+    const data = await this.program.account.bondState.fetch(publicKey);
+    return { publicKey, ...data };
   }
   /**
    * Fetch validator bond data or null if not found
    */
   async getValidatorBond(bondType, bondName, vote) {
-    const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
-    try {
-      return await this.program.account.validatorBond.fetch(address);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get bond collateral type
-   */
-  async getBondCollateralType(bondType, bondName) {
-    const bondState = await this.getBondState(bondType, bondName);
-    return bondState.bondState.collateralType;
+    const [publicKey] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
+    const data = await this.program.account.validatorBond.fetch(publicKey);
+    return { publicKey, ...data };
   }
   /**
    * Get validator bond account balance (in SOL)
-   * @param bondType - Type of the bond
-   * @param bondName - Name of the bond
-   * @param vote - Vote account public key
-   * @return Balance in lamports
    */
   async getValidatorBondBalance(bondType, bondName, vote) {
     const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
-    const bondStateData = await this.getBondState(bondType, bondName);
-    const bondStateCollateralType = bondStateData.bondState.collateralType;
-    return await matchVariant(bondStateCollateralType, {
+    const bondState = await this.getBondState(bondType, bondName);
+    const collateralType = bondState.collateralType;
+    return await matchVariant(collateralType, {
       native: async () => {
         const accountInfo = await this.connection.getAccountInfo(address).catch(() => null);
         if (!accountInfo) {
@@ -6941,7 +6899,7 @@ var JBondClient = class _JBondClient {
         const tokenAccount = getAssociatedTokenAddressSync(mint, address, true);
         try {
           const balance = await this.connection.getTokenAccountBalance(tokenAccount);
-          return Number(balance.value.uiAmount ?? 0) * LAMPORTS_PER_SOL;
+          return solToLamports(balance.value.amount).toNumber();
         } catch {
           return 0;
         }
@@ -6952,8 +6910,8 @@ var JBondClient = class _JBondClient {
    * Get total collected collateral for a bond state
    */
   async getBondStateTotalCollected(bondType, bondName, votes) {
-    const bondStateData = await this.getBondState(bondType, bondName);
-    const bondStateCollateralType = bondStateData.bondState.collateralType;
+    const bondState = await this.getBondState(bondType, bondName);
+    const collateralType = bondState.collateralType;
     const chunk = (arr, n = 100) => {
       const res = [];
       for (let i = 0; i < arr.length; i += n) {
@@ -6961,7 +6919,7 @@ var JBondClient = class _JBondClient {
       }
       return res;
     };
-    return await matchVariant(bondStateCollateralType, {
+    return await matchVariant(collateralType, {
       native: async () => {
         const addresses = votes.map((vote) => {
           const [address] = this.pda.validatorBond(bondType, bondName, new PublicKey(vote));
@@ -7011,189 +6969,16 @@ var JBondClient = class _JBondClient {
       }
     });
   }
-  /**
-   * Get transaction history for a specific validator bond account
-   */
-  async getHistory(bondType, bondName, vote, options) {
-    const [legacyValidatorBondAccount] = PublicKey.findProgramAddressSync(
-      [
-        Buffer.from("validator_bond" /* ValidatorBond */),
-        new PublicKey(vote).toBuffer()
-      ],
-      this.programId
-    );
-    const validatorBond = this.pda.validatorBond(bondType, bondName, vote);
-    const legacySignatures = (await this.connection.getSignaturesForAddress(
-      legacyValidatorBondAccount,
-      {
-        limit: options?.limit || 1e3,
-        before: options?.before,
-        until: options?.until
-      },
-      "confirmed"
-    )).filter((sig) => !sig.err);
-    const newSignatures = (await this.connection.getSignaturesForAddress(
-      validatorBond[0],
-      {
-        limit: options?.limit || 1e3,
-        before: options?.before,
-        until: options?.until
-      },
-      "confirmed"
-    )).filter((sig) => !sig.err);
-    const signatureStrings = legacySignatures.map((sig) => sig.signature);
-    signatureStrings.push(...newSignatures.map((sig) => sig.signature));
-    const signatures = [...legacySignatures, ...newSignatures];
-    const BATCH_SIZE = 100;
-    const allTransactions = [];
-    for (let i = 0; i < signatureStrings.length; i += BATCH_SIZE) {
-      const batch = signatureStrings.slice(i, i + BATCH_SIZE);
-      const transactions = await this.connection.getParsedTransactions(
-        batch,
-        {
-          maxSupportedTransactionVersion: 0,
-          commitment: "confirmed"
-        }
-      );
-      allTransactions.push(...transactions);
-    }
-    const cluster = options?.cluster || "mainnet-beta";
-    const history = [];
-    for (const [idx, tx] of allTransactions.entries()) {
-      const sigInfo = signatures[idx];
-      if (!tx || !tx.meta || tx.meta.err !== null) {
-        continue;
-      }
-      try {
-        const slot = tx.slot || 0;
-        const instructions = tx.transaction.message.instructions;
-        for (const instruction of instructions) {
-          if ("programId" in instruction && instruction.programId.equals(this.options.programId ?? this.program.programId)) {
-            const ixData = instruction;
-            if ("parsed" in ixData && ixData.parsed) {
-              continue;
-            }
-            const data = ixData.data;
-            if (!data) {
-              continue;
-            }
-            let type = null;
-            let amount = 0;
-            try {
-              const dataBuffer = bs582.decode(data);
-              if (dataBuffer.length >= 8) {
-                const discriminator = dataBuffer.subarray(0, 8);
-                const legacyRegisterDiscriminator = this.getInstructionDiscriminator("register");
-                const legacyTopUpDiscriminator = this.getInstructionDiscriminator("topUp");
-                const legacyClaimDiscriminator = this.getInstructionDiscriminator("claim");
-                const legacyWithdrawDiscriminator = this.getInstructionDiscriminator("withdraw");
-                const bondRegisterDiscriminator = this.getInstructionDiscriminator("bondRegister");
-                const bondTopUpDiscriminator = this.getInstructionDiscriminator("bondTopUp");
-                const bondClaimDiscriminator = this.getInstructionDiscriminator("bondClaim");
-                const bondWithdrawDiscriminator = this.getInstructionDiscriminator("bondWithdraw");
-                console.log("Discriminator:", Buffer.from(discriminator).toString("hex"));
-                if (Buffer.from(discriminator).equals(Buffer.from(legacyRegisterDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondRegisterDiscriminator))) {
-                  type = "deposit" /* Deposit */;
-                  if (dataBuffer.length >= 16 && Buffer.from(discriminator).equals(Buffer.from(legacyRegisterDiscriminator))) {
-                    const amountBytes = dataBuffer.subarray(8, 16);
-                    const amountBN = new import_bn.BN(amountBytes, "le");
-                    amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
-                  }
-                } else if (dataBuffer.length >= 16) {
-                  const amountBytes = dataBuffer.subarray(8, 16);
-                  const amountBN = new import_bn.BN(amountBytes, "le");
-                  amount = amountBN.toNumber() / LAMPORTS_PER_SOL;
-                  if (Buffer.from(discriminator).equals(Buffer.from(legacyTopUpDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondTopUpDiscriminator))) {
-                    type = "deposit" /* Deposit */;
-                  } else if (Buffer.from(discriminator).equals(Buffer.from(legacyClaimDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondClaimDiscriminator))) {
-                    type = "compensation" /* Compensation */;
-                  } else if (Buffer.from(discriminator).equals(Buffer.from(legacyWithdrawDiscriminator)) || Buffer.from(discriminator).equals(Buffer.from(bondWithdrawDiscriminator))) {
-                    type = "withdrawal" /* Withdrawal */;
-                  }
-                }
-              }
-            } catch (e) {
-              console.warn("Failed to decode instruction data:", e);
-            }
-            if (type && (amount > 0 || type === "deposit" /* Deposit */)) {
-              history.push({
-                signature: sigInfo.signature,
-                slot,
-                epoch: slotToEpoch(slot, cluster),
-                type,
-                amount
-              });
-            }
-          }
-        }
-      } catch (error) {
-        console.error(`Error processing transaction ${sigInfo.signature}:`, error);
-      }
-    }
-    return history.toSorted((a, b) => b.slot - a.slot);
-  }
-  /**
-   * Get full transaction history by paginating through results
-   * @param bondType
-   * @param bondName
-   * @param voteAccount
-   * @param pageSize
-   */
-  async getFullHistory(bondType, bondName, voteAccount, pageSize = 100) {
-    const allHistory = [];
-    let before;
-    while (true) {
-      const batch = await this.getHistory(bondType, bondName, voteAccount, {
-        limit: pageSize,
-        before
-      });
-      if (batch.length === 0) {
-        break;
-      }
-      allHistory.push(...batch);
-      before = batch.at(-1)?.signature;
-      if (batch.length < pageSize) {
-        break;
-      }
-    }
-    return allHistory;
-  }
-  /**
-   * Get instruction discriminator from IDL
-   * @param instructionName
-   * @private
-   */
-  getInstructionDiscriminator(instructionName) {
-    const legacyDiscriminators = {
-      register: [211, 124, 67, 15, 211, 194, 178, 240],
-      topUp: [181, 157, 89, 67, 143, 182, 52, 72],
-      claim: [62, 198, 214, 193, 213, 159, 108, 210],
-      withdraw: [183, 18, 70, 156, 148, 109, 161, 34]
-    };
-    if (legacyDiscriminators[instructionName]) {
-      return new Uint8Array(legacyDiscriminators[instructionName]);
-    }
-    if (instructionName.startsWith("bond")) {
-      const instruction = this.program.idl.instructions.find((ix) => ix.name === instructionName);
-      if (!instruction) {
-        throw new Error(`Instruction ${instructionName} not found in IDL`);
-      }
-      if (!instruction.discriminator || !Array.isArray(instruction.discriminator)) {
-        throw new Error(`Discriminator not found for instruction ${instructionName}`);
-      }
-      return new Uint8Array(instruction.discriminator);
-    }
-    throw new Error(`Unknown instruction: ${instructionName}`);
-  }
   /**
    * Get bond state stats
    * @param state
    * @private
    */
   async getBondStateStats(state) {
-    const validatorBonds = await this.getValidatorBondsByState(state.bondType, state.name);
+    const bondType = anchorToBondType(state.bondType);
+    const validatorBonds = await this.getBondValidatorStates(bondType, state.name);
     const totalCollected = await this.getBondStateTotalCollected(
-      state.bondType,
+      bondType,
       state.name,
       validatorBonds.map((vb) => vb.voteAccount)
     );
@@ -7202,8 +6987,36 @@ var JBondClient = class _JBondClient {
       status: this.getBondStateSessionStatus(state)
     };
   }
-  lamports(n) {
-    return new import_bn.BN((n ?? 0) * LAMPORTS_PER_SOL);
+  /**
+   * Get all validator bonds for a given bond state
+   */
+  async getBondValidatorStates(bondType, bondName) {
+    const [bondState] = this.pda.bondState(bondType, bondName);
+    const accounts = await this.program.account.validatorBond.all([
+      {
+        memcmp: {
+          offset: 8,
+          // discriminator
+          bytes: bondState.toBase58()
+        }
+      }
+    ]);
+    const result = [];
+    for (const { publicKey, account } of accounts) {
+      result.push({ publicKey, ...account });
+    }
+    return result;
+  }
+  /**
+   * Get session status for bond state
+   */
+  getBondStateSessionStatus(bondState) {
+    const now = Math.floor(Date.now() / 1e3);
+    if (bondState.sessionFinishTs.toNumber() > now) {
+      return 0 /* Live */;
+    } else {
+      return 1 /* Finished */;
+    }
   }
 };
 /*! Bundled license information:
@@ -7220,6 +7033,6 @@ buffer/index.js:
    *)
 */
 
-export { BondClientEnv, BondStateStatusVariant, BondTransactionType, BondTypeVariant, ENV_PROGRAM_ID, JBondClient, JPOOL_STAKE_POOL, NodeWallet, Seeds, SessionStatus, bondTypeToSeed };
+export { BOND_STATE_SEED, BondClientEnv, BondTransactionType, BondType, CROWDFUNDING_BOND_SEED, ENV_PROGRAM_ID, GLOBAL_STATE_SEED, JBondClient, NodeWallet, STANDARD_BOND_SEED, SessionStatus, VALIDATOR_BOND_SEED };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map