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