@1money/protocol-ts-sdk 1.0.14

package/lib/index.js

@@ -0,0 +1,1591 @@
+'use strict';Object.defineProperty(exports,'__esModule',{value:true});var axios$1=require('axios'),viem=require('viem'),rlp=require('@ethereumjs/rlp');/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};/**
+ * Derives the token account address given the wallet address and mint address.
+ *
+ * Address is 20 byte, 160 bits. Let's say if we want to support 50 billion
+ * accounts on 1money. That's about 36 bits. There are 124 bits remaining. In
+ * other words, the collision probability is 1/2^124, which is very very low.
+ * So, we will be fine to just use the hash of the wallet address and mint
+ * address to derive the token account address.
+ *
+ * @param walletAddress - The wallet address (20 bytes)
+ * @param mintAddress - The mint address (20 bytes)
+ * @returns The derived token account address
+ */
+function deriveTokenAddress(walletAddress, mintAddress) {
+    var walletBytes = walletAddress.startsWith('0x')
+        ? viem.hexToBytes(walletAddress)
+        : viem.stringToBytes(walletAddress);
+    var mintBytes = mintAddress.startsWith('0x')
+        ? viem.hexToBytes(mintAddress)
+        : viem.stringToBytes(mintAddress);
+    var combined = new Uint8Array(walletBytes.length + mintBytes.length);
+    combined.set(walletBytes, 0);
+    combined.set(mintBytes, walletBytes.length);
+    var hashHex = viem.keccak256(combined);
+    var hashBytes = viem.hexToBytes(hashHex);
+    var addressBytes = hashBytes.slice(12);
+    return viem.bytesToHex(addressBytes);
+}// concurrent
+function safePromiseAll(arr) {
+    // @ts-expect-error
+    if (!arr || !arr.length)
+        return Promise.resolve([]);
+    return Promise.all(arr);
+}
+// serial
+function safePromiseLine(arr) {
+    return __awaiter(this, void 0, void 0, function () {
+        var res, i, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!arr || !arr.length)
+                        return [2 /*return*/, []];
+                    res = [];
+                    i = 0;
+                    _c.label = 1;
+                case 1:
+                    if (!(i < arr.length)) return [3 /*break*/, 6];
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 4, , 5]);
+                    _b = (_a = res).push;
+                    return [4 /*yield*/, arr[i](i)];
+                case 3:
+                    _b.apply(_a, [_c.sent()]);
+                    return [3 /*break*/, 5];
+                case 4:
+                    _c.sent();
+                    return [3 /*break*/, 5];
+                case 5:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 6: return [2 /*return*/, res];
+            }
+        });
+    });
+}function _typeof(ele) {
+    if (typeof ele !== 'object')
+        return (typeof ele).toLowerCase();
+    var typeStr = Object.prototype.toString.call(ele);
+    return typeStr.slice(8, typeStr.length - 1).toLowerCase();
+}/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+/**
+ * 4KB JS implementation of secp256k1 ECDSA / Schnorr signatures & ECDH.
+ * Compliant with RFC6979 & BIP340.
+ * @module
+ */
+/**
+ * Curve params. secp256k1 is short weierstrass / koblitz curve. Equation is y² == x³ + ax + b.
+ * * P = `2n**256n-2n**32n-2n**977n` // field over which calculations are done
+ * * N = `2n**256n - 0x14551231950b75fc4402da1732fc9bebfn` // group order, amount of curve points
+ * * h = `1n` // cofactor
+ * * a = `0n` // equation param
+ * * b = `7n` // equation param
+ * * Gx, Gy are coordinates of Generator / base point
+ */
+const secp256k1_CURVE = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+    b: 7n,
+    Gx: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+    Gy: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n,
+};
+const { p: P, n: N, Gx, Gy, b: _b } = secp256k1_CURVE;
+const L = 32; // field / group byte length
+const L2 = 64;
+// Helpers and Precomputes sections are reused between libraries
+// ## Helpers
+// ----------
+// error helper, messes-up stack trace
+const err = (m = '') => {
+    throw new Error(m);
+};
+const isBig = (n) => typeof n === 'bigint'; // is big integer
+const isStr = (s) => typeof s === 'string'; // is string
+const isBytes = (a) => a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+/** assert is Uint8Array (of specific length) */
+const abytes = (a, l) => !isBytes(a) || (typeof l === 'number' && l > 0 && a.length !== l)
+    ? err('Uint8Array expected')
+    : a;
+/** create Uint8Array */
+const u8n = (len) => new Uint8Array(len);
+const u8fr = (buf) => Uint8Array.from(buf);
+const padh = (n, pad) => n.toString(16).padStart(pad, '0');
+const bytesToHex = (b) => Array.from(abytes(b))
+    .map((e) => padh(e, 2))
+    .join('');
+const C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }; // ASCII characters
+const _ch = (ch) => {
+    if (ch >= C._0 && ch <= C._9)
+        return ch - C._0; // '2' => 50-48
+    if (ch >= C.A && ch <= C.F)
+        return ch - (C.A - 10); // 'B' => 66-(65-10)
+    if (ch >= C.a && ch <= C.f)
+        return ch - (C.a - 10); // 'b' => 98-(97-10)
+    return;
+};
+const hexToBytes = (hex) => {
+    const e = 'hex invalid';
+    if (!isStr(hex))
+        return err(e);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        return err(e);
+    const array = u8n(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        // treat each char as ASCII
+        const n1 = _ch(hex.charCodeAt(hi)); // parse first char, multiply it by 16
+        const n2 = _ch(hex.charCodeAt(hi + 1)); // parse second char
+        if (n1 === undefined || n2 === undefined)
+            return err(e);
+        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9
+    }
+    return array;
+};
+/** normalize hex or ui8a to ui8a */
+const toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+const cr = () => globalThis?.crypto; // WebCrypto is available in all modern environments
+const subtle = () => cr()?.subtle ?? err('crypto.subtle must be defined');
+// prettier-ignore
+const concatBytes = (...arrs) => {
+    const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0)); // create u8a of summed length
+    let pad = 0; // walk through each array,
+    arrs.forEach(a => { r.set(a, pad); pad += a.length; }); // ensure they have proper type
+    return r;
+};
+/** WebCrypto OS-level CSPRNG (random number generator). Will throw when not available. */
+const randomBytes = (len = L) => {
+    const c = cr();
+    return c.getRandomValues(u8n(len));
+};
+const big = BigInt;
+const arange = (n, min, max, msg = 'bad number: out of range') => isBig(n) && min <= n && n < max ? n : err(msg);
+/** modular division */
+const M = (a, b = P) => {
+    const r = a % b;
+    return r >= 0n ? r : b + r;
+};
+const modN = (a) => M(a, N);
+/** Modular inversion using eucledian GCD (non-CT). No negative exponent for now. */
+// prettier-ignore
+const invert = (num, md) => {
+    if (num === 0n || md <= 0n)
+        err('no inverse n=' + num + ' mod=' + md);
+    let a = M(num, md), b = md, x = 0n, u = 1n;
+    while (a !== 0n) {
+        const q = b / a, r = b % a;
+        const m = x - u * q;
+        b = a, a = r, x = u, u = m;
+    }
+    return b === 1n ? M(x, md) : err('no inverse'); // b is gcd at this point
+};
+const apoint = (p) => (p instanceof Point ? p : err('Point expected'));
+// ## End of Helpers
+// -----------------
+/** secp256k1 formula. Koblitz curves are subclass of weierstrass curves with a=0, making it x³+b */
+const koblitz = (x) => M(M(x * x) * x + _b);
+/** assert is field element or 0 */
+const afield0 = (n) => arange(n, 0n, P);
+/** assert is field element */
+const afield = (n) => arange(n, 1n, P);
+/** assert is group elem */
+const agroup = (n) => arange(n, 1n, N);
+const isEven = (y) => (y & 1n) === 0n;
+/** create Uint8Array of byte n */
+const u8of = (n) => Uint8Array.of(n);
+const getPrefix = (y) => u8of(isEven(y) ? 0x02 : 0x03);
+/** lift_x from BIP340 calculates square root. Validates x, then validates root*root. */
+const lift_x = (x) => {
+    // Let c = x³ + 7 mod p. Fail if x ≥ p. (also fail if x < 1)
+    const c = koblitz(afield(x));
+    // c = √y
+    // y = c^((p+1)/4) mod p
+    // This formula works for fields p = 3 mod 4 -- a special, fast case.
+    // Paper: "Square Roots from 1;24,51,10 to Dan Shanks".
+    let r = 1n;
+    for (let num = c, e = (P + 1n) / 4n; e > 0n; e >>= 1n) {
+        // powMod: modular exponentiation.
+        if (e & 1n)
+            r = (r * num) % P; // Uses exponentiation by squaring.
+        num = (num * num) % P; // Not constant-time.
+    }
+    return M(r * r) === c ? r : err('sqrt invalid'); // check if result is valid
+};
+/** Point in 3d xyz projective coordinates. 3d takes less inversions than 2d. */
+class Point {
+    static BASE;
+    static ZERO;
+    px;
+    py;
+    pz;
+    constructor(px, py, pz) {
+        this.px = afield0(px);
+        this.py = afield(py); // y can't be 0 in Projective
+        this.pz = afield0(pz);
+        Object.freeze(this);
+    }
+    /** Convert Uint8Array or hex string to Point. */
+    static fromBytes(bytes) {
+        abytes(bytes);
+        let p = undefined;
+        // First byte is prefix, rest is data. There are 2 kinds: compressed & uncompressed:
+        // * [0x02 or 0x03][32-byte x coordinate]
+        // * [0x04]        [32-byte x coordinate][32-byte y coordinate]
+        const head = bytes[0];
+        const tail = bytes.subarray(1);
+        const x = sliceBytesNumBE(tail, 0, L);
+        const len = bytes.length;
+        // Compressed 33-byte point, 0x02 or 0x03 prefix
+        if (len === L + 1 && [0x02, 0x03].includes(head)) {
+            // Equation is y² == x³ + ax + b. We calculate y from x.
+            // y = √y²; there are two solutions: y, -y. Determine proper solution based on prefix
+            let y = lift_x(x);
+            const evenY = isEven(y);
+            const evenH = isEven(big(head));
+            if (evenH !== evenY)
+                y = M(-y);
+            p = new Point(x, y, 1n);
+        }
+        // Uncompressed 65-byte point, 0x04 prefix
+        if (len === L2 + 1 && head === 0x04)
+            p = new Point(x, sliceBytesNumBE(tail, L, L2), 1n);
+        // Validate point
+        return p ? p.assertValidity() : err('bad point: not on curve');
+    }
+    /** Equality check: compare points P&Q. */
+    equals(other) {
+        const { px: X1, py: Y1, pz: Z1 } = this;
+        const { px: X2, py: Y2, pz: Z2 } = apoint(other); // checks class equality
+        const X1Z2 = M(X1 * Z2);
+        const X2Z1 = M(X2 * Z1);
+        const Y1Z2 = M(Y1 * Z2);
+        const Y2Z1 = M(Y2 * Z1);
+        return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+    }
+    is0() {
+        return this.equals(I);
+    }
+    /** Flip point over y coordinate. */
+    negate() {
+        return new Point(this.px, M(-this.py), this.pz);
+    }
+    /** Point doubling: P+P, complete formula. */
+    double() {
+        return this.add(this);
+    }
+    /**
+     * Point addition: P+Q, complete, exception-free formula
+     * (Renes-Costello-Batina, algo 1 of [2015/1060](https://eprint.iacr.org/2015/1060)).
+     * Cost: `12M + 0S + 3*a + 3*b3 + 23add`.
+     */
+    // prettier-ignore
+    add(other) {
+        const { px: X1, py: Y1, pz: Z1 } = this;
+        const { px: X2, py: Y2, pz: Z2 } = apoint(other);
+        const a = 0n;
+        const b = _b;
+        let X3 = 0n, Y3 = 0n, Z3 = 0n;
+        const b3 = M(b * 3n);
+        let t0 = M(X1 * X2), t1 = M(Y1 * Y2), t2 = M(Z1 * Z2), t3 = M(X1 + Y1); // step 1
+        let t4 = M(X2 + Y2); // step 5
+        t3 = M(t3 * t4);
+        t4 = M(t0 + t1);
+        t3 = M(t3 - t4);
+        t4 = M(X1 + Z1);
+        let t5 = M(X2 + Z2); // step 10
+        t4 = M(t4 * t5);
+        t5 = M(t0 + t2);
+        t4 = M(t4 - t5);
+        t5 = M(Y1 + Z1);
+        X3 = M(Y2 + Z2); // step 15
+        t5 = M(t5 * X3);
+        X3 = M(t1 + t2);
+        t5 = M(t5 - X3);
+        Z3 = M(a * t4);
+        X3 = M(b3 * t2); // step 20
+        Z3 = M(X3 + Z3);
+        X3 = M(t1 - Z3);
+        Z3 = M(t1 + Z3);
+        Y3 = M(X3 * Z3);
+        t1 = M(t0 + t0); // step 25
+        t1 = M(t1 + t0);
+        t2 = M(a * t2);
+        t4 = M(b3 * t4);
+        t1 = M(t1 + t2);
+        t2 = M(t0 - t2); // step 30
+        t2 = M(a * t2);
+        t4 = M(t4 + t2);
+        t0 = M(t1 * t4);
+        Y3 = M(Y3 + t0);
+        t0 = M(t5 * t4); // step 35
+        X3 = M(t3 * X3);
+        X3 = M(X3 - t0);
+        t0 = M(t3 * t1);
+        Z3 = M(t5 * Z3);
+        Z3 = M(Z3 + t0); // step 40
+        return new Point(X3, Y3, Z3);
+    }
+    /**
+     * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+     * Uses {@link wNAF} for base point.
+     * Uses fake point to mitigate side-channel leakage.
+     * @param n scalar by which point is multiplied
+     * @param safe safe mode guards against timing attacks; unsafe mode is faster
+     */
+    multiply(n, safe = true) {
+        if (!safe && n === 0n)
+            return I;
+        agroup(n);
+        if (n === 1n)
+            return this;
+        if (this.equals(G))
+            return wNAF(n).p;
+        // init result point & fake point
+        let p = I;
+        let f = G;
+        for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+            // if bit is present, add to point
+            // if not present, add to fake, for timing safety
+            if (n & 1n)
+                p = p.add(d);
+            else if (safe)
+                f = f.add(d);
+        }
+        return p;
+    }
+    /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+    toAffine() {
+        const { px: x, py: y, pz: z } = this;
+        // fast-paths for ZERO point OR Z=1
+        if (this.equals(I))
+            return { x: 0n, y: 0n };
+        if (z === 1n)
+            return { x, y };
+        const iz = invert(z, P);
+        // (Z * Z^-1) must be 1, otherwise bad math
+        if (M(z * iz) !== 1n)
+            err('inverse invalid');
+        // x = X*Z^-1; y = Y*Z^-1
+        return { x: M(x * iz), y: M(y * iz) };
+    }
+    /** Checks if the point is valid and on-curve. */
+    assertValidity() {
+        const { x, y } = this.toAffine(); // convert to 2d xy affine point.
+        afield(x); // must be in range 1 <= x,y < P
+        afield(y);
+        // y² == x³ + ax + b, equation sides must be equal
+        return M(y * y) === koblitz(x) ? this : err('bad point: not on curve');
+    }
+    /** Converts point to 33/65-byte Uint8Array. */
+    toBytes(isCompressed = true) {
+        const { x, y } = this.assertValidity().toAffine();
+        const x32b = numTo32b(x);
+        if (isCompressed)
+            return concatBytes(getPrefix(y), x32b);
+        return concatBytes(u8of(0x04), x32b, numTo32b(y));
+    }
+    /** Create 3d xyz point from 2d xy. (0, 0) => (0, 1, 0), not (0, 0, 1) */
+    static fromAffine(ap) {
+        const { x, y } = ap;
+        return x === 0n && y === 0n ? I : new Point(x, y, 1n);
+    }
+    toHex(isCompressed) {
+        return bytesToHex(this.toBytes(isCompressed));
+    }
+    static fromPrivateKey(k) {
+        return G.multiply(toPrivScalar(k));
+    }
+    static fromHex(hex) {
+        return Point.fromBytes(toU8(hex));
+    }
+    get x() {
+        return this.toAffine().x;
+    }
+    get y() {
+        return this.toAffine().y;
+    }
+    toRawBytes(isCompressed) {
+        return this.toBytes(isCompressed);
+    }
+}
+/** Generator / base point */
+const G = new Point(Gx, Gy, 1n);
+/** Identity / zero point */
+const I = new Point(0n, 1n, 0n);
+// Static aliases
+Point.BASE = G;
+Point.ZERO = I;
+/** `Q = u1⋅G + u2⋅R`. Verifies Q is not ZERO. Unsafe: non-CT. */
+const doubleScalarMulUns = (R, u1, u2) => {
+    return G.multiply(u1, false).add(R.multiply(u2, false)).assertValidity();
+};
+const bytesToNumBE = (b) => big('0x' + (bytesToHex(b) || '0'));
+const sliceBytesNumBE = (b, from, to) => bytesToNumBE(b.subarray(from, to));
+const B256 = 2n ** 256n; // secp256k1 is weierstrass curve. Equation is x³ + ax + b.
+/** Number to 32b. Must be 0 <= num < B256. validate, pad, to bytes. */
+const numTo32b = (num) => hexToBytes(padh(arange(num, 0n, B256), L2));
+/** Normalize private key to scalar (bigint). Verifies scalar is in range 1<s<N */
+const toPrivScalar = (pr) => {
+    const num = isBig(pr) ? pr : bytesToNumBE(toU8(pr, L));
+    return arange(num, 1n, N, 'private key invalid 3');
+};
+/** For Signature malleability, validates sig.s is bigger than N/2. */
+const highS = (n) => n > N >> 1n;
+/** ECDSA Signature class. Supports only compact 64-byte representation, not DER. */
+class Signature {
+    r;
+    s;
+    recovery;
+    constructor(r, s, recovery) {
+        this.r = agroup(r); // 1 <= r < N
+        this.s = agroup(s); // 1 <= s < N
+        if (recovery != null)
+            this.recovery = recovery;
+        Object.freeze(this);
+    }
+    /** Create signature from 64b compact (r || s) representation. */
+    static fromBytes(b) {
+        abytes(b, L2);
+        const r = sliceBytesNumBE(b, 0, L);
+        const s = sliceBytesNumBE(b, L, L2);
+        return new Signature(r, s);
+    }
+    toBytes() {
+        const { r, s } = this;
+        return concatBytes(numTo32b(r), numTo32b(s));
+    }
+    /** Copy signature, with newly added recovery bit. */
+    addRecoveryBit(bit) {
+        return new Signature(this.r, this.s, bit);
+    }
+    hasHighS() {
+        return highS(this.s);
+    }
+    toCompactRawBytes() {
+        return this.toBytes();
+    }
+    toCompactHex() {
+        return bytesToHex(this.toBytes());
+    }
+    recoverPublicKey(msg) {
+        return recoverPublicKey(this, msg);
+    }
+    static fromCompact(hex) {
+        return Signature.fromBytes(toU8(hex, L2));
+    }
+    assertValidity() {
+        return this;
+    }
+    normalizeS() {
+        const { r, s, recovery } = this;
+        return highS(s) ? new Signature(r, modN(-s), recovery) : this;
+    }
+}
+/**
+ * RFC6979: ensure ECDSA msg is X bytes, convert to BigInt.
+ * RFC suggests optional truncating via bits2octets.
+ * FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits,
+ * which matches bits2int. bits2int can produce res>N.
+ */
+const bits2int = (bytes) => {
+    const delta = bytes.length * 8 - 256;
+    if (delta > 1024)
+        err('msg invalid'); // our CUSTOM check, "just-in-case": prohibit long inputs
+    const num = bytesToNumBE(bytes);
+    return delta > 0 ? num >> big(delta) : num;
+};
+/** int2octets can't be used; pads small msgs with 0: BAD for truncation as per RFC vectors */
+const bits2int_modN = (bytes) => modN(bits2int(abytes(bytes)));
+const signOpts = { lowS: true };
+// RFC6979 signature generation, preparation step.
+const prepSig = (msgh, priv, opts = signOpts) => {
+    if (['der', 'recovered', 'canonical'].some((k) => k in opts))
+        // legacy opts
+        err('option not supported');
+    let { lowS, extraEntropy } = opts; // generates low-s sigs by default
+    if (lowS == null)
+        lowS = true; // RFC6979 3.2: we skip step A
+    const i2o = numTo32b; // int to octets
+    const h1i = bits2int_modN(toU8(msgh)); // msg bigint
+    const h1o = i2o(h1i); // msg octets
+    const d = toPrivScalar(priv); // validate private key, convert to bigint
+    const seed = [i2o(d), h1o]; // Step D of RFC6979 3.2
+    /** RFC6979 3.6: additional k' (optional). See {@link ExtraEntropy}. */
+    // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')
+    if (extraEntropy)
+        seed.push(extraEntropy === true ? randomBytes(L) : toU8(extraEntropy));
+    const m = h1i; // convert msg to bigint
+    // Converts signature params into point w r/s, checks result for validity.
+    // To transform k => Signature:
+    // q = k⋅G
+    // r = q.x mod n
+    // s = k^-1(m + rd) mod n
+    const k2sig = (kBytes) => {
+        // RFC 6979 Section 3.2, step 3: k = bits2int(T)
+        // Important: all mod() calls here must be done over N
+        const k = bits2int(kBytes);
+        if (!(1n <= k && k < N))
+            return; // Check 0 < k < CURVE.n
+        const q = G.multiply(k).toAffine(); // q = k⋅G
+        const r = modN(q.x); // r = q.x mod n
+        if (r === 0n)
+            return;
+        const ik = invert(k, N); // k^-1 mod n, NOT mod P
+        const s = modN(ik * modN(m + modN(d * r))); // s = k^-1(m + rd) mod n
+        if (s === 0n)
+            return;
+        let normS = s; // normalized S
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & 1n); // recovery bit (2 or 3, when q.x > n)
+        if (lowS && highS(s)) {
+            // if lowS was passed, ensure s is always
+            normS = modN(-s); // in the bottom half of CURVE.n
+            recovery ^= 1;
+        }
+        return new Signature(r, normS, recovery); // use normS, not s
+    };
+    return { seed: concatBytes(...seed), k2sig };
+};
+// HMAC-DRBG from NIST 800-90. Minimal, non-full-spec - used for RFC6979 signatures.
+const hmacDrbg = (asynchronous) => {
+    let v = u8n(L); // Steps B, C of RFC6979 3.2: set hashLen
+    let k = u8n(L); // In our case, it's always equal to L
+    let i = 0; // Iterations counter, will throw when over max
+    const NULL = u8n(0);
+    const reset = () => {
+        v.fill(1);
+        k.fill(0);
+        i = 0;
+    };
+    const max = 1000;
+    const _e = 'drbg: tried 1000 values';
+    {
+        // asynchronous=true
+        // h = hmac(K || V || ...)
+        const h = (...b) => etc.hmacSha256Async(k, v, ...b);
+        const reseed = async (seed = NULL) => {
+            // HMAC-DRBG reseed() function. Steps D-G
+            k = await h(u8of(0x00), seed); // k = hmac(K || V || 0x00 || seed)
+            v = await h(); // v = hmac(K || V)
+            if (seed.length === 0)
+                return;
+            k = await h(u8of(0x01), seed); // k = hmac(K || V || 0x01 || seed)
+            v = await h(); // v = hmac(K || V)
+        };
+        // HMAC-DRBG generate() function
+        const gen = async () => {
+            if (i++ >= max)
+                err(_e);
+            v = await h(); // v = hmac(K || V)
+            return v; // this diverges from noble-curves: we don't allow arbitrary output len!
+        };
+        // Do not reuse returned fn for more than 1 sig:
+        // 1) it's slower (JIT screws up). 2. unsafe (async race conditions)
+        return async (seed, pred) => {
+            reset();
+            await reseed(seed); // Steps D-G
+            let res = undefined; // Step H: grind until k is in [1..n-1]
+            while (!(res = pred(await gen())))
+                await reseed(); // test predicate until it returns ok
+            reset();
+            return res;
+        };
+    }
+};
+/**
+ * Sign a msg hash using secp256k1. Async.
+ * Follows [SEC1](https://secg.org/sec1-v2.pdf) 4.1.2 & RFC6979.
+ * It's suggested to enable hedging ({@link ExtraEntropy}) to prevent fault attacks.
+ * @param msgh - message HASH, not message itself e.g. sha256(message)
+ * @param priv - private key
+ * @param opts - `lowS: true` prevents malleability, `extraEntropy: true` enables hedging
+ */
+const signAsync = async (msgh, priv, opts = signOpts) => {
+    // Re-run drbg until k2sig returns ok
+    const { seed, k2sig } = prepSig(msgh, priv, opts);
+    const sig = await hmacDrbg()(seed, k2sig);
+    return sig;
+};
+/**
+ * ECDSA public key recovery. Requires msg hash and recovery id.
+ * Follows [SEC1](https://secg.org/sec1-v2.pdf) 4.1.6.
+ */
+const recoverPublicKey = (sig, msgh) => {
+    const { r, s, recovery } = sig;
+    // 0 or 1 recovery id determines sign of "y" coordinate.
+    // 2 or 3 means q.x was >N.
+    if (![0, 1, 2, 3].includes(recovery))
+        err('recovery id invalid');
+    const h = bits2int_modN(toU8(msgh, L)); // Truncate hash
+    const radj = recovery === 2 || recovery === 3 ? r + N : r;
+    afield(radj); // ensure q.x is still a field element
+    const head = getPrefix(big(recovery)); // head is 0x02 or 0x03
+    const Rb = concatBytes(head, numTo32b(radj)); // concat head + r
+    const R = Point.fromBytes(Rb);
+    const ir = invert(radj, N); // r^-1
+    const u1 = modN(-h * ir); // -hr^-1
+    const u2 = modN(s * ir); // sr^-1
+    return doubleScalarMulUns(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)
+};
+// FIPS 186 B.4.1 compliant key generation produces private keys with modulo bias being neglible.
+// takes >N+8 bytes, returns (hash mod n-1)+1
+const hashToPrivateKey = (hash) => {
+    hash = toU8(hash);
+    if (hash.length < L + 8 || hash.length > 1024)
+        err('expected 40-1024b');
+    const num = M(bytesToNumBE(hash), N - 1n);
+    return numTo32b(num + 1n);
+};
+const _sha = 'SHA-256';
+/** Math, hex, byte helpers. Not in `utils` because utils share API with noble-curves. */
+const etc = {
+    hexToBytes: hexToBytes,
+    bytesToHex: bytesToHex,
+    concatBytes: concatBytes,
+    bytesToNumberBE: bytesToNumBE,
+    numberToBytesBE: numTo32b,
+    mod: M,
+    invert: invert, // math utilities
+    hmacSha256Async: async (key, ...msgs) => {
+        const s = subtle();
+        const name = 'HMAC';
+        const k = await s.importKey('raw', key, { name, hash: { name: _sha } }, false, ['sign']);
+        return u8n(await s.sign(name, k, concatBytes(...msgs)));
+    },
+    hmacSha256Sync: undefined, // For TypeScript. Actual logic is below
+    hashToPrivateKey: hashToPrivateKey,
+    randomBytes: randomBytes,
+};
+// ## Precomputes
+// --------------
+const W = 8; // W is window size
+const scalarBits = 256;
+const pwindows = Math.ceil(scalarBits / W) + 1; // 33 for W=8
+const pwindowSize = 2 ** (W - 1); // 128 for W=8
+const precompute = () => {
+    const points = [];
+    let p = G;
+    let b = p;
+    for (let w = 0; w < pwindows; w++) {
+        b = p;
+        points.push(b);
+        for (let i = 1; i < pwindowSize; i++) {
+            b = b.add(p);
+            points.push(b);
+        } // i=1, bc we skip 0
+        p = b.double();
+    }
+    return points;
+};
+let Gpows = undefined; // precomputes for base point G
+// const-time negate
+const ctneg = (cnd, p) => {
+    const n = p.negate();
+    return cnd ? n : p;
+};
+/**
+ * Precomputes give 12x faster getPublicKey(), 10x sign(), 2x verify() by
+ * caching multiples of G (base point). Cache is stored in 32MB of RAM.
+ * Any time `G.multiply` is done, precomputes are used.
+ * Not used for getSharedSecret, which instead multiplies random pubkey `P.multiply`.
+ *
+ * w-ary non-adjacent form (wNAF) precomputation method is 10% slower than windowed method,
+ * but takes 2x less RAM. RAM reduction is possible by utilizing `.subtract`.
+ *
+ * !! Precomputes can be disabled by commenting-out call of the wNAF() inside Point#multiply().
+ */
+const wNAF = (n) => {
+    const comp = Gpows || (Gpows = precompute());
+    let p = I;
+    let f = G; // f must be G, or could become I in the end
+    const pow_2_w = 2 ** W; // 256 for W=8
+    const maxNum = pow_2_w; // 256 for W=8
+    const mask = big(pow_2_w - 1); // 255 for W=8 == mask 0b11111111
+    const shiftBy = big(W); // 8 for W=8
+    for (let w = 0; w < pwindows; w++) {
+        let wbits = Number(n & mask); // extract W bits.
+        n >>= shiftBy; // shift number by W bits.
+        if (wbits > pwindowSize) {
+            wbits -= maxNum;
+            n += 1n;
+        } // split if bits > max: +224 => 256-32
+        const off = w * pwindowSize;
+        const offF = off; // offsets, evaluate both
+        const offP = off + Math.abs(wbits) - 1;
+        const isEven = w % 2 !== 0; // conditions, evaluate both
+        const isNeg = wbits < 0;
+        if (wbits === 0) {
+            // off == I: can't add it. Adding random offF instead.
+            f = f.add(ctneg(isEven, comp[offF])); // bits are 0: add garbage to fake point
+        }
+        else {
+            p = p.add(ctneg(isNeg, comp[offP])); // bits are 1: add to result point
+        }
+    }
+    return { p, f }; // return both real and fake points for JIT
+};/**
+ * RLP encode a payload into a digest
+ * @param payload Payload to encode
+ * @returns RLP encoded payload
+ */
+function encodePayload(payload) {
+    if (_typeof(payload) === 'array') {
+        var formatted = payload.map(function (v) {
+            if (_typeof(v) === 'string') {
+                if (/^0x[0-9a-fA-F]+$/.test(v)) {
+                    // hex-encoded data → raw bytes
+                    return viem.hexToBytes(v);
+                }
+                else if (!isNaN(+v)) {
+                    // number-like string → hex → bytes
+                    return v === '0' ? new Uint8Array([]) : viem.hexToBytes(viem.numberToHex(+v));
+                }
+                else {
+                    // plain string → UTF-8 bytes
+                    return new TextEncoder().encode(v);
+                }
+            }
+            else if (_typeof(v) === 'number' || _typeof(v) === 'bigint') {
+                // produce minimal hex, then arrayify
+                return v === 0 || v === BigInt(0) ? new Uint8Array([]) : viem.hexToBytes(viem.numberToHex(v));
+            }
+            else if (_typeof(v) === 'boolean') {
+                return v ? Uint8Array.from([1]) : new Uint8Array([]);
+            }
+            else {
+                return v;
+            }
+        });
+        return rlp.encode(formatted);
+    }
+    if (_typeof(payload) === 'boolean') {
+        return rlp.encode(payload ? Uint8Array.from([1]) : new Uint8Array([]));
+    }
+    return rlp.encode(payload);
+}
+/**
+ * Sign a message using the provided private key
+ * @param payload Payload to sign
+ * @param privateKey Private key to sign with
+ * @returns Signature object with r, s, v components
+ */
+function signMessage(payload, privateKey) {
+    return __awaiter(this, void 0, void 0, function () {
+        var encoded, digestHex, digest, privateKeyBytes, signature, compact, rBytes, sBytes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    encoded = encodePayload(payload);
+                    digestHex = viem.keccak256(encoded);
+                    digest = viem.hexToBytes(digestHex);
+                    privateKeyBytes = viem.hexToBytes(privateKey);
+                    return [4 /*yield*/, signAsync(digest, privateKeyBytes, { lowS: true })];
+                case 1:
+                    signature = _a.sent();
+                    compact = signature.toCompactRawBytes();
+                    rBytes = compact.subarray(0, 32);
+                    sBytes = compact.subarray(32, 64);
+                    return [2 /*return*/, {
+                            r: viem.bytesToHex(rBytes),
+                            s: viem.bytesToHex(sBytes),
+                            v: signature.recovery,
+                        }];
+            }
+        });
+    });
+}
+function toHex(value) {
+    var type = _typeof(value);
+    try {
+        switch (type) {
+            case 'boolean':
+                return viem.boolToHex(value);
+            case 'number':
+            case 'bigint':
+                return viem.numberToHex(value);
+            case 'string':
+                if (!isNaN(+value))
+                    return viem.numberToHex(+value);
+                return viem.stringToHex(value);
+            case 'uint8array':
+            case 'uint16array':
+            case 'uint32array':
+            case 'int8array':
+            case 'int16array':
+            case 'int32array':
+            case 'arraybuffer':
+                return viem.bytesToHex(value);
+            case 'array':
+                if (value.length === 0)
+                    return '0x';
+                else if (value.every(function (item) { return typeof item === 'number'; }))
+                    return viem.bytesToHex(Uint8Array.from(value));
+                else
+                    return viem.bytesToHex(viem.stringToBytes(JSON.stringify(value)));
+            default:
+                return viem.bytesToHex(viem.stringToBytes(JSON.stringify(value)));
+        }
+    }
+    catch (e) {
+        console.error('[1Money toHex]: ', e);
+        return '0x';
+    }
+}function encodeRlpListHeader(length) {
+    if (length < 56) {
+        // Short list: single byte prefix
+        return Uint8Array.from([0xc0 + length]);
+    }
+    else {
+        // Long list: prefix 0xf7 + length of length + actual length bytes
+        var lenBytes = [];
+        var temp = length;
+        while (temp > 0) {
+            lenBytes.unshift(temp & 0xff);
+            temp >>= 8;
+        }
+        return Uint8Array.from(__spreadArray([0xf7 + lenBytes.length], lenBytes, true));
+    }
+}
+function calcTxHash(payload, signature) {
+    var pEncode = encodePayload(payload);
+    var vEncode = rlp.encode(typeof signature.v === 'boolean'
+        ? signature.v
+            ? Uint8Array.from([1])
+            : new Uint8Array([])
+        : BigInt(signature.v));
+    var rEncode = rlp.encode(viem.hexToBytes(signature.r));
+    var sEncode = rlp.encode(viem.hexToBytes(signature.s));
+    var vrsBytes = new Uint8Array(vEncode.length + rEncode.length + sEncode.length);
+    vrsBytes.set(vEncode, 0);
+    vrsBytes.set(rEncode, vEncode.length);
+    vrsBytes.set(sEncode, vEncode.length + rEncode.length);
+    var header = encodeRlpListHeader(pEncode.length + vrsBytes.length);
+    var encoded = new Uint8Array(header.length + pEncode.length + vrsBytes.length);
+    encoded.set(header, 0);
+    encoded.set(pEncode, header.length);
+    encoded.set(vrsBytes, header.length + pEncode.length);
+    return viem.keccak256(encoded);
+}var ResponsePromise = /** @class */ (function () {
+    function ResponsePromise() {
+        var _this = this;
+        this.promiseWrapper = new Promise(function (resolve, reject) {
+            _this._resolve = resolve;
+            _this._reject = reject;
+        });
+        this._restScope = ['success', 'failure', 'error', 'login', 'timeout'];
+        var _loop_1 = function (i) {
+            var method = this_1._restScope[i];
+            if (!method)
+                return "continue";
+            this_1.promiseWrapper[method] = function (_callback) {
+                // @ts-ignore
+                if (typeof _callback === 'function')
+                    _this["_".concat(method)] = _callback;
+                var wrapper = _this.promiseWrapper;
+                delete wrapper[method];
+                var methods = _this._restScope.slice();
+                methods.splice(methods.indexOf(method), 1);
+                if (methods.every(function (_m) { return !!_m && !wrapper[_m]; }))
+                    delete wrapper.rest;
+                return wrapper;
+            };
+        };
+        var this_1 = this;
+        for (var i = 0; i < this._restScope.length; i++) {
+            _loop_1(i);
+        }
+        this.promiseWrapper.rest = function (onRest, scope) {
+            // @ts-ignore
+            if (typeof onRest === 'function')
+                _this._rest = onRest;
+            var wrapper = _this.promiseWrapper;
+            delete wrapper.rest;
+            _this._restScope = scope || _this._restScope;
+            // @ts-ignore
+            if (_this._restScope.length === 0) {
+                console.warn('[1Money client]: The ".rest(cb, scope)" scope is empty and will never be triggered!');
+            }
+            else {
+                var deletedCounter_1 = 0;
+                _this._restScope.forEach(function (method) {
+                    if (!method)
+                        return;
+                    if (wrapper[method]) {
+                        delete wrapper[method];
+                    }
+                    else {
+                        deletedCounter_1++;
+                    }
+                });
+                if (deletedCounter_1 === _this._restScope.length) {
+                    console.warn("[1Money client]: The \"".concat(_this._restScope.join(', '), "\" had been called and the \"rest\" will never be triggered!"));
+                }
+            }
+            return wrapper;
+        };
+    }
+    return ResponsePromise;
+}());
+var Request = /** @class */ (function () {
+    function Request(config) {
+        this._config = config || {};
+        this.axios = axios$1;
+        this.parseError = this.parseError.bind(this);
+        this.setting = this.setting.bind(this);
+        this.request = this.request.bind(this);
+    }
+    Request.prototype.parseError = function (err) {
+        var _a, _b, _c, _d, _f, _g, _h, _j, _k;
+        if (typeof err === 'string')
+            err = new Error(err);
+        // Ensure we have a valid error object
+        if (!err || (_typeof(err) !== 'object' && _typeof(err) !== 'error')) {
+            err = new Error('Unknown error occurred');
+        }
+        var name = (_a = err === null || err === void 0 ? void 0 : err.name) !== null && _a !== void 0 ? _a : 'Error';
+        var message = (_d = (_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : (_c = err === null || err === void 0 ? void 0 : err.toString) === null || _c === void 0 ? void 0 : _c.call(err)) !== null && _d !== void 0 ? _d : 'Unknown error';
+        var stack = (_f = err === null || err === void 0 ? void 0 : err.stack) !== null && _f !== void 0 ? _f : '';
+        var status = (_h = (_g = err === null || err === void 0 ? void 0 : err.response) === null || _g === void 0 ? void 0 : _g.status) !== null && _h !== void 0 ? _h : 500;
+        var data = (_k = (_j = err === null || err === void 0 ? void 0 : err.response) === null || _j === void 0 ? void 0 : _j.data) !== null && _k !== void 0 ? _k : undefined;
+        // Validate status code
+        if (typeof status !== 'number' || status < 100 || status > 599) {
+            return {
+                name: 'InvalidStatusError',
+                message: 'Invalid HTTP status code',
+                stack: stack,
+                status: 500,
+                data: data
+            };
+        }
+        return {
+            name: name,
+            message: message,
+            stack: stack,
+            status: status,
+            data: data
+        };
+    };
+    Request.prototype.setting = function (config) {
+        if (!config)
+            return console.warn('[1Money client]: setting method required correct parameters!');
+        this._config = __assign(__assign({}, this._config), config);
+    };
+    Request.prototype.request = function (options) {
+        var _this = this;
+        // Set default security headers
+        options.withCredentials = typeof options.withCredentials === 'boolean' ? options.withCredentials : true;
+        options.headers = options.headers || {};
+        options.headers['Accept'] = options.headers['Accept'] || '*/*';
+        options.headers['X-Requested-With'] = options.headers['X-Requested-With'] || 'XMLHttpRequest';
+        options.headers['X-Content-Type-Options'] = options.headers['X-Content-Type-Options'] || 'nosniff';
+        var _a = this._config, initOnSuccess = _a.onSuccess, initOnFailure = _a.onFailure, initOnLogin = _a.onLogin, initOnError = _a.onError, initOnTimeout = _a.onTimeout, initIsSuccess = _a.isSuccess, initIsLogin = _a.isLogin, initTimeout = _a.timeout;
+        var onSuccess = options.onSuccess, onFailure = options.onFailure, onLogin = options.onLogin, onError = options.onError, onTimeout = options.onTimeout, isSuccess = options.isSuccess, isLogin = options.isLogin, timeout = options.timeout;
+        var rules = {
+            success: isSuccess !== null && isSuccess !== void 0 ? isSuccess : initIsSuccess,
+            login: isLogin !== null && isLogin !== void 0 ? isLogin : initIsLogin,
+        };
+        var ResPromise = new ResponsePromise();
+        Promise.resolve().then(function () {
+            var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+            var callbacks = {
+                success: (_d = (_c = (_b = (_a = ResPromise._success) !== null && _a !== void 0 ? _a : (~ResPromise._restScope.indexOf('success') ? ResPromise._rest : undefined)) !== null && _b !== void 0 ? _b : onSuccess) !== null && _c !== void 0 ? _c : initOnSuccess) !== null && _d !== void 0 ? _d : (function (r, h) { return r; }),
+                failure: (_j = (_h = (_g = (_f = ResPromise._failure) !== null && _f !== void 0 ? _f : (~ResPromise._restScope.indexOf('failure') ? ResPromise._rest : undefined)) !== null && _g !== void 0 ? _g : onFailure) !== null && _h !== void 0 ? _h : initOnFailure) !== null && _j !== void 0 ? _j : (function (v, h) { return v; }),
+                error: (_p = (_o = (_l = (_k = ResPromise._error) !== null && _k !== void 0 ? _k : (~ResPromise._restScope.indexOf('error') ? ResPromise._rest : undefined)) !== null && _l !== void 0 ? _l : onError) !== null && _o !== void 0 ? _o : initOnError) !== null && _p !== void 0 ? _p : (function (v, h) { return v; }),
+                login: (_t = (_s = (_r = (_q = ResPromise._login) !== null && _q !== void 0 ? _q : (~ResPromise._restScope.indexOf('login') ? ResPromise._rest : undefined)) !== null && _r !== void 0 ? _r : onLogin) !== null && _s !== void 0 ? _s : initOnLogin) !== null && _t !== void 0 ? _t : (function (v, h) { return v; }),
+                timeout: (_x = (_w = (_v = (_u = ResPromise._timeout) !== null && _u !== void 0 ? _u : (~ResPromise._restScope.indexOf('timeout') ? ResPromise._rest : undefined)) !== null && _v !== void 0 ? _v : onTimeout) !== null && _w !== void 0 ? _w : initOnTimeout) !== null && _x !== void 0 ? _x : (function (v, h) { return v; }),
+            };
+            var existedHandler = {
+                success: !!(ResPromise._success ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('success')) ||
+                    onSuccess ||
+                    initOnSuccess),
+                failure: !!(ResPromise._failure ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('failure')) ||
+                    onFailure ||
+                    initOnFailure),
+                login: !!(ResPromise._login ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('login')) ||
+                    onLogin ||
+                    initOnLogin),
+                error: !!(ResPromise._error ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('error')) ||
+                    onError ||
+                    initOnError),
+                timeout: !!(ResPromise._timeout ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('timeout')) ||
+                    onTimeout ||
+                    initOnTimeout),
+            };
+            var existedChainHandler = {
+                success: !!(ResPromise._success ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('success'))),
+                failure: !!(ResPromise._failure ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('failure'))),
+                login: !!(ResPromise._login ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('login'))),
+                error: !!(ResPromise._error ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('error'))),
+                timeout: !!(ResPromise._timeout ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('timeout'))),
+            };
+            var errorHandler = function (e, headers) { return __awaiter(_this, void 0, void 0, function () {
+                var err, result, _e_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            err = this.parseError(e);
+                            return [4 /*yield*/, Promise.resolve(callbacks.error(err, headers))];
+                        case 1:
+                            result = _a.sent();
+                            if (existedChainHandler.error)
+                                err = result;
+                            existedHandler.error ? ResPromise._resolve(err) : ResPromise._reject(err);
+                            return [3 /*break*/, 3];
+                        case 2:
+                            _e_1 = _a.sent();
+                            ResPromise._reject(this.parseError(_e_1));
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); };
+            var timer = null;
+            var isTimeout = false;
+            var _timeout = timeout !== null && timeout !== void 0 ? timeout : initTimeout;
+            // Cleanup function for timeout
+            var cleanup = function () {
+                if (timer !== null) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            };
+            if (_timeout) {
+                timer = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                    var err, res, e_1;
+                    var _a, _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _c.trys.push([0, 2, , 3]);
+                                isTimeout = true;
+                                cleanup();
+                                err = this.parseError('timeout');
+                                return [4 /*yield*/, Promise.resolve(callbacks.timeout(err, (_a = options.headers) !== null && _a !== void 0 ? _a : {}))];
+                            case 1:
+                                res = _c.sent();
+                                if (existedChainHandler.timeout)
+                                    err = res;
+                                existedHandler.timeout ? ResPromise._resolve(err) : ResPromise._reject(err);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_1 = _c.sent();
+                                errorHandler(e_1, (_b = options.headers) !== null && _b !== void 0 ? _b : {});
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); }, _timeout);
+            }
+            _this.axios(options).then(function (response) { return __awaiter(_this, void 0, void 0, function () {
+                var status, data, headers, doSuccess, doLogin, res, result, result, result, e_2;
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (isTimeout)
+                                return [2 /*return*/];
+                            cleanup();
+                            status = response.status, data = response.data, headers = response.headers;
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 8, , 9]);
+                            doSuccess = (_a = rules.success) === null || _a === void 0 ? void 0 : _a.call(rules, data, status, headers);
+                            doLogin = (_b = rules.login) === null || _b === void 0 ? void 0 : _b.call(rules, data, status, headers);
+                            res = data;
+                            if (!doLogin) return [3 /*break*/, 3];
+                            return [4 /*yield*/, Promise.resolve(callbacks.login(data, headers))];
+                        case 2:
+                            result = _c.sent();
+                            if (existedChainHandler.login)
+                                res = result;
+                            return [3 /*break*/, 7];
+                        case 3:
+                            if (!doSuccess) return [3 /*break*/, 5];
+                            return [4 /*yield*/, Promise.resolve(callbacks.success(data, headers))];
+                        case 4:
+                            result = _c.sent();
+                            if (existedChainHandler.success)
+                                res = result;
+                            return [3 /*break*/, 7];
+                        case 5: return [4 /*yield*/, Promise.resolve(callbacks.failure(data, headers))];
+                        case 6:
+                            result = _c.sent();
+                            if (existedChainHandler.failure)
+                                res = result;
+                            _c.label = 7;
+                        case 7:
+                            ResPromise._resolve(res);
+                            return [3 /*break*/, 9];
+                        case 8:
+                            e_2 = _c.sent();
+                            errorHandler(e_2, headers);
+                            return [3 /*break*/, 9];
+                        case 9: return [2 /*return*/];
+                    }
+                });
+            }); }).catch(function (err) { return __awaiter(_this, void 0, void 0, function () {
+                var status, data, headers, res, doLogin, e_3;
+                var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l, _o, _p, _q, _r, _s, _t, _u, _v;
+                return __generator(this, function (_w) {
+                    switch (_w.label) {
+                        case 0:
+                            if (isTimeout)
+                                return [2 /*return*/];
+                            cleanup();
+                            console.error("[1Money client]: Error(".concat((_a = err.status) !== null && _a !== void 0 ? _a : 500, ", ").concat((_b = err.code) !== null && _b !== void 0 ? _b : 'UNKNOWN', "), Message: ").concat(err.message, ", Config: ").concat((_c = err.config) === null || _c === void 0 ? void 0 : _c.method, ", ").concat((_f = (_d = err.config) === null || _d === void 0 ? void 0 : _d.baseURL) !== null && _f !== void 0 ? _f : '').concat((_h = (_g = err.config) === null || _g === void 0 ? void 0 : _g.url) !== null && _h !== void 0 ? _h : '', ", ").concat(JSON.stringify((_k = (_j = err.config) === null || _j === void 0 ? void 0 : _j.headers) !== null && _k !== void 0 ? _k : {}), ", Request: ").concat(JSON.stringify((_o = (_l = err.config) === null || _l === void 0 ? void 0 : _l.data) !== null && _o !== void 0 ? _o : {}), ";"));
+                            status = (_q = (_p = err.response) === null || _p === void 0 ? void 0 : _p.status) !== null && _q !== void 0 ? _q : 500;
+                            data = (_s = (_r = err.response) === null || _r === void 0 ? void 0 : _r.data) !== null && _s !== void 0 ? _s : {};
+                            headers = (_u = (_t = err.response) === null || _t === void 0 ? void 0 : _t.headers) !== null && _u !== void 0 ? _u : {};
+                            _w.label = 1;
+                        case 1:
+                            _w.trys.push([1, 5, , 6]);
+                            res = data;
+                            doLogin = (_v = rules.login) === null || _v === void 0 ? void 0 : _v.call(rules, data, status, headers);
+                            if (!doLogin) return [3 /*break*/, 3];
+                            return [4 /*yield*/, Promise.resolve(callbacks.login(res, headers))];
+                        case 2:
+                            res = _w.sent();
+                            ResPromise._resolve(res);
+                            return [3 /*break*/, 4];
+                        case 3:
+                            errorHandler(err, headers);
+                            _w.label = 4;
+                        case 4: return [3 /*break*/, 6];
+                        case 5:
+                            e_3 = _w.sent();
+                            errorHandler(e_3, headers);
+                            return [3 /*break*/, 6];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        return ResPromise.promiseWrapper;
+    };
+    return Request;
+}());var _a = new Request({
+    isSuccess: function (res, status) { return status === 200 && res.code == 0; },
+    isLogin: function (res, status) { return status === 401 || res.code == 401; },
+    timeout: 10000
+}), request = _a.request, setting = _a.setting, axios = _a.axios;
+function get(url, options) {
+    return request(__assign(__assign({}, options), { method: 'get', url: url }));
+}
+function post(url, data, options) {
+    return request(__assign(__assign({}, options), { method: 'post', url: url, data: data, headers: __assign({ 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers) }));
+}
+function postForm(url, data, options) {
+    return request(__assign(__assign({}, options), { method: 'post', url: url, data: data, headers: __assign({ 'Content-Type': 'multipart/form-data' }, options === null || options === void 0 ? void 0 : options.headers) }));
+}
+function put(url, data, options) {
+    return request(__assign(__assign({}, options), { method: 'put', url: url, data: data, headers: __assign({ 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers) }));
+}
+function patch(url, data, options) {
+    return request(__assign(__assign({}, options), { method: 'patch', url: url, data: data, headers: __assign({ 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers) }));
+}
+function del(url, data, options) {
+    return request(__assign(__assign({}, options), { method: 'delete', url: url, data: data, headers: __assign({ 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers) }));
+}
+function setInitConfig(config) {
+    var baseURL = config.baseURL, rest = __rest(config, ["baseURL"]);
+    axios.defaults.baseURL = baseURL || (typeof window !== 'undefined' ? location.origin : void 0);
+    setting(rest);
+}
+var axiosStatic = axios;
+var client = {
+    get: get,
+    post: post,
+    postForm: postForm,
+    del: del,
+    put: put,
+    patch: patch,
+    setInitConfig: setInitConfig,
+    axiosStatic: axiosStatic
+};// Base URLs for the API
+var TESTNET_API_URL = 'https://api.testnet.1money.network';
+var MAINNET_API_URL = 'https://api.1money.network';
+var LOCAL_API_URL = 'http://localhost:18555';
+// API version
+var API_VERSION = 'v1';var API_PREFIX$5 = "/".concat(API_VERSION, "/accounts");
+/**
+ * Accounts API methods
+ */
+var accountsApi = {
+    /**
+     * Get account nonce
+     * @param address Address of the account to lookup nonce for
+     * @returns Promise with account info response
+     */
+    getNonce: function (address) {
+        return get("".concat(API_PREFIX$5, "/nonce?address=").concat(address), { withCredentials: false });
+    },
+    /**
+     * Get associated token account
+     * @param address Address of the account to lookup associated token account for
+     * @param token Token address to lookup associated token account for
+     * @returns Promise with associated token account response
+     */
+    getTokenAccount: function (address, token) {
+        return get("".concat(API_PREFIX$5, "/token_account?address=").concat(address, "&token=").concat(token), { withCredentials: false });
+    }
+};var API_PREFIX$4 = "/".concat(API_VERSION, "/checkpoints");
+/**
+ * Checkpoint API methods
+ */
+var checkpointsApi = {
+    /**
+     * Get the current checkpoint number
+     * @returns Promise with checkpoint number response
+     */
+    getNumber: function () {
+        return get("".concat(API_PREFIX$4, "/number"), { withCredentials: false });
+    },
+    /**
+     * Get checkpoint by hash
+     * @param hash Hash of the checkpoint to lookup
+     * @param full Whether to include full transaction details
+     * @returns Promise with checkpoint response
+     */
+    getByHash: function (hash, full) {
+        if (full === void 0) { full = false; }
+        return get("".concat(API_PREFIX$4, "/by_hash?hash=").concat(hash, "&full=").concat(full), { withCredentials: false });
+    },
+    /**
+     * Get checkpoint by number
+     * @param number Number of the checkpoint to lookup
+     * @param full Whether to include full transaction details
+     * @returns Promise with checkpoint response
+     */
+    getByNumber: function (number, full) {
+        if (full === void 0) { full = false; }
+        return get("".concat(API_PREFIX$4, "/by_number?number=").concat(number, "&full=").concat(full), { withCredentials: false });
+    }
+};var API_PREFIX$3 = "/".concat(API_VERSION, "/tokens");
+/**
+ * Tokens API methods
+ */
+var tokensApi = {
+    /**
+     * Get token metadata
+     * @param token Token address to lookup metadata for
+     * @returns Promise with token metadata response
+     */
+    getTokenMetadata: function (token) {
+        return get("".concat(API_PREFIX$3, "/token_metadata?token=").concat(token), { withCredentials: false });
+    },
+    /**
+     * Manage token blacklist
+     * @param payload Token blacklist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageBlacklist: function (payload) {
+        return post("".concat(API_PREFIX$3, "/manage_blacklist"), payload, { withCredentials: false });
+    },
+    /**
+     * Manage token whitelist
+     * @param payload Token whitelist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageWhitelist: function (payload) {
+        return post("".concat(API_PREFIX$3, "/manage_whitelist"), payload, { withCredentials: false });
+    },
+    /**
+     * Burn tokens
+     * @param payload Token burn request payload
+     * @returns Promise with transaction hash response
+     */
+    burnToken: function (payload) {
+        return post("".concat(API_PREFIX$3, "/burn"), payload, { withCredentials: false });
+    },
+    /**
+     * Grant or revoke token authority
+     * @param payload Token authority request payload
+     * @returns Promise with transaction hash response
+     */
+    grantAuthority: function (payload) {
+        return post("".concat(API_PREFIX$3, "/grant_authority"), payload, { withCredentials: false });
+    },
+    /**
+     * Issue new token
+     * @param payload Token issue request payload
+     * @returns Promise with transaction hash and token address response
+     */
+    issueToken: function (payload) {
+        return post("".concat(API_PREFIX$3, "/issue"), payload, { withCredentials: false });
+    },
+    /**
+     * Mint tokens
+     * @param payload Token mint request payload
+     * @returns Promise with transaction hash response
+     */
+    mintToken: function (payload) {
+        return post("".concat(API_PREFIX$3, "/mint"), payload, { withCredentials: false });
+    },
+    /**
+     * Pause or unpause token
+     * @param payload Token pause request payload
+     * @returns Promise with transaction hash response
+     */
+    pauseToken: function (payload) {
+        return post("".concat(API_PREFIX$3, "/pause"), payload, { withCredentials: false });
+    },
+    /**
+     * Update token metadata
+     * @param payload Token metadata request payload
+     * @returns Promise with transaction hash response
+     */
+    updateMetadata: function (payload) {
+        return post("".concat(API_PREFIX$3, "/update_metadata"), payload, { withCredentials: false });
+    }
+};var API_PREFIX$2 = "/".concat(API_VERSION, "/transactions");
+/**
+ * Transactions API methods
+ */
+var transactionsApi = {
+    /**
+     * Get transaction by hash
+     * @param hash Hash of the transaction to lookup
+     * @returns Promise with transaction response
+     */
+    getByHash: function (hash) {
+        return get("".concat(API_PREFIX$2, "/by_hash?hash=").concat(hash), { withCredentials: false });
+    },
+    /**
+     * Get transaction receipt by hash
+     * @param hash Hash of the transaction to lookup receipt for
+     * @returns Promise with transaction receipt response
+     */
+    getReceiptByHash: function (hash) {
+        return get("".concat(API_PREFIX$2, "/receipt/by_hash?hash=").concat(hash), { withCredentials: false });
+    },
+    /**
+     * Estimate transaction fee
+     * @param from Address of the transaction author
+     * @param value Value of the transaction
+     * @param token Optional token address
+     * @returns Promise with fee estimate response
+     */
+    estimateFee: function (from, value, token) {
+        var url = "".concat(API_PREFIX$2, "/estimate_fee?from=").concat(from, "&value=").concat(value);
+        if (token) {
+            url += "&token=".concat(token);
+        }
+        return get(url, { withCredentials: false });
+    },
+    /**
+     * Submit payment transaction
+     * @param payload Payment transaction payload
+     * @returns Promise with transaction hash response
+     */
+    payment: function (payload) {
+        return post("".concat(API_PREFIX$2, "/payment"), payload, { withCredentials: false });
+    }
+};var API_PREFIX$1 = "/".concat(API_VERSION, "/chains");
+/**
+ * Checkpoint API methods
+ */
+var chainApi = {
+    /**
+     * Get the current chain id
+     * @returns Promise with chain id response
+     */
+    getChainId: function () {
+        return get("".concat(API_PREFIX$1, "/chain_id"), { withCredentials: false });
+    },
+};var API_PREFIX = "/".concat(API_VERSION, "/states");
+/**
+ * State API methods
+ */
+var stateApi = {
+    /**
+     * Get latest epoch checkpoint
+     * @returns Promise with latest epoch checkpoint response
+     */
+    getLatestEpochCheckpoint: function () {
+        return get("".concat(API_PREFIX, "/latest_epoch_checkpoint"), { withCredentials: false });
+    }
+};// Authority types
+var AuthorityType;
+(function (AuthorityType) {
+    AuthorityType["MasterMint"] = "MasterMint";
+    AuthorityType["MintBurnTokens"] = "MintBurnTokens";
+    AuthorityType["Pause"] = "Pause";
+    AuthorityType["ManageList"] = "ManageList";
+    AuthorityType["UpdateMetadata"] = "UpdateMetadata";
+})(AuthorityType || (AuthorityType = {}));
+var AuthorityAction;
+(function (AuthorityAction) {
+    AuthorityAction["Grant"] = "Grant";
+    AuthorityAction["Revoke"] = "Revoke";
+})(AuthorityAction || (AuthorityAction = {}));
+var ManageListAction;
+(function (ManageListAction) {
+    ManageListAction["Add"] = "Add";
+    ManageListAction["Remove"] = "Remove";
+})(ManageListAction || (ManageListAction = {}));
+var PauseAction;
+(function (PauseAction) {
+    PauseAction["Pause"] = "Pause";
+    PauseAction["Unpause"] = "Unpause";
+})(PauseAction || (PauseAction = {}));/**
+ * API client for 1money network
+ * @param options Configuration options
+ * @param options.network Network to use (testnet, mainnet, local)
+ * @param options.timeout Request timeout in milliseconds
+ * @param options.chainId Custom chain ID (overrides the default for the selected network)
+ */
+function api(options) {
+    var network = (options === null || options === void 0 ? void 0 : options.network) || 'mainnet';
+    var baseURL = MAINNET_API_URL;
+    // Set the base URL based on the network
+    switch (network) {
+        case 'mainnet':
+            baseURL = MAINNET_API_URL;
+            break;
+        case 'testnet':
+            baseURL = TESTNET_API_URL;
+            break;
+        case 'local':
+            baseURL = LOCAL_API_URL;
+            break;
+    }
+    // Initialize API configuration
+    setInitConfig({
+        baseURL: baseURL,
+        // Treat status code 200 as success
+        isSuccess: function (_res, status) { return status === 200; },
+        timeout: (options === null || options === void 0 ? void 0 : options.timeout) || 10000
+    });
+    return {
+        /**
+         * Accounts API methods
+         */
+        accounts: accountsApi,
+        /**
+         * Checkpoint API methods
+         */
+        checkpoints: checkpointsApi,
+        /**
+         * Tokens API methods
+         */
+        tokens: tokensApi,
+        /**
+         * Transactions API methods
+         */
+        transactions: transactionsApi,
+        /**
+         * Chain API methods
+         */
+        chain: chainApi,
+        /**
+         * State API methods
+         */
+        state: stateApi,
+    };
+}var index = {
+    api: api,
+    client: client,
+};exports._typeof=_typeof;exports.api=api;exports.calcTxHash=calcTxHash;exports.client=client;exports.default=index;exports.deriveTokenAddress=deriveTokenAddress;exports.encodePayload=encodePayload;exports.safePromiseAll=safePromiseAll;exports.safePromiseLine=safePromiseLine;exports.signMessage=signMessage;exports.toHex=toHex;