@notabene/verify-proof 1.11.0 → 1.11.1-next.1

package/dist/xrpl-7HQLIDAK.cjs

@@ -0,0 +1,1174 @@
+'use strict';
+
+var buffer = require('buffer');
+var chunkOAXNH5XR_cjs = require('./chunk-OAXNH5XR.cjs');
+var javascriptSdk = require('@notabene/javascript-sdk');
+var xrpl = require('xrpl');
+
+if (typeof globalThis !== 'undefined' && !globalThis.Buffer) { globalThis.Buffer = buffer.Buffer; }
+
+// node_modules/@noble/hashes/cryptoNode.js
+var require_cryptoNode = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@noble/hashes/cryptoNode.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.crypto = void 0;
+    var nc = chunkOAXNH5XR_cjs.__require("crypto");
+    exports.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+  }
+});
+
+// node_modules/@noble/hashes/utils.js
+var require_utils = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@noble/hashes/utils.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+    exports.isBytes = isBytes;
+    exports.anumber = anumber;
+    exports.abytes = abytes;
+    exports.ahash = ahash;
+    exports.aexists = aexists;
+    exports.aoutput = aoutput;
+    exports.u8 = u8;
+    exports.u32 = u32;
+    exports.clean = clean;
+    exports.createView = createView;
+    exports.rotr = rotr;
+    exports.rotl = rotl;
+    exports.byteSwap = byteSwap;
+    exports.byteSwap32 = byteSwap32;
+    exports.bytesToHex = bytesToHex;
+    exports.hexToBytes = hexToBytes;
+    exports.asyncLoop = asyncLoop;
+    exports.utf8ToBytes = utf8ToBytes;
+    exports.bytesToUtf8 = bytesToUtf8;
+    exports.toBytes = toBytes;
+    exports.kdfInputToBytes = kdfInputToBytes;
+    exports.concatBytes = concatBytes;
+    exports.checkOpts = checkOpts;
+    exports.createHasher = createHasher;
+    exports.createOptHasher = createOptHasher;
+    exports.createXOFer = createXOFer;
+    exports.randomBytes = randomBytes;
+    var crypto_1 = require_cryptoNode();
+    function isBytes(a) {
+      return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+    }
+    function anumber(n) {
+      if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("positive integer expected, got " + n);
+    }
+    function abytes(b, ...lengths) {
+      if (!isBytes(b))
+        throw new Error("Uint8Array expected");
+      if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+    }
+    function ahash(h) {
+      if (typeof h !== "function" || typeof h.create !== "function")
+        throw new Error("Hash should be wrapped by utils.createHasher");
+      anumber(h.outputLen);
+      anumber(h.blockLen);
+    }
+    function aexists(instance, checkFinished = true) {
+      if (instance.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (checkFinished && instance.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function aoutput(out, instance) {
+      abytes(out);
+      const min = instance.outputLen;
+      if (out.length < min) {
+        throw new Error("digestInto() expects output buffer of length at least " + min);
+      }
+    }
+    function u8(arr) {
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+    }
+    function u32(arr) {
+      return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    }
+    function clean(...arrays) {
+      for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+      }
+    }
+    function createView(arr) {
+      return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    }
+    function rotr(word, shift) {
+      return word << 32 - shift | word >>> shift;
+    }
+    function rotl(word, shift) {
+      return word << shift | word >>> 32 - shift >>> 0;
+    }
+    exports.isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    function byteSwap(word) {
+      return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+    }
+    exports.swap8IfBE = exports.isLE ? (n) => n : (n) => byteSwap(n);
+    exports.byteSwapIfBE = exports.swap8IfBE;
+    function byteSwap32(arr) {
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+      }
+      return arr;
+    }
+    exports.swap32IfBE = exports.isLE ? (u) => u : byteSwap32;
+    var hasHexBuiltin = /* @__PURE__ */ (() => (
+      // @ts-ignore
+      typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+    ))();
+    var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+    function bytesToHex(bytes) {
+      abytes(bytes);
+      if (hasHexBuiltin)
+        return bytes.toHex();
+      let hex = "";
+      for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+      }
+      return hex;
+    }
+    var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function asciiToBase16(ch) {
+      if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0;
+      if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10);
+      if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10);
+      return;
+    }
+    function hexToBytes(hex) {
+      if (typeof hex !== "string")
+        throw new Error("hex string expected, got " + typeof hex);
+      if (hasHexBuiltin)
+        return Uint8Array.fromHex(hex);
+      const hl = hex.length;
+      const al = hl / 2;
+      if (hl % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + hl);
+      const array = new Uint8Array(al);
+      for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === void 0 || n2 === void 0) {
+          const char = hex[hi] + hex[hi + 1];
+          throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2;
+      }
+      return array;
+    }
+    var nextTick = async () => {
+    };
+    exports.nextTick = nextTick;
+    async function asyncLoop(iters, tick, cb) {
+      let ts = Date.now();
+      for (let i = 0; i < iters; i++) {
+        cb(i);
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+          continue;
+        await (0, exports.nextTick)();
+        ts += diff;
+      }
+    }
+    function utf8ToBytes(str) {
+      if (typeof str !== "string")
+        throw new Error("string expected");
+      return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function bytesToUtf8(bytes) {
+      return new TextDecoder().decode(bytes);
+    }
+    function toBytes(data) {
+      if (typeof data === "string")
+        data = utf8ToBytes(data);
+      abytes(data);
+      return data;
+    }
+    function kdfInputToBytes(data) {
+      if (typeof data === "string")
+        data = utf8ToBytes(data);
+      abytes(data);
+      return data;
+    }
+    function concatBytes(...arrays) {
+      let sum = 0;
+      for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+      }
+      const res = new Uint8Array(sum);
+      for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+      }
+      return res;
+    }
+    function checkOpts(defaults, opts) {
+      if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+        throw new Error("options should be object or undefined");
+      const merged = Object.assign(defaults, opts);
+      return merged;
+    }
+    var Hash = class {
+    };
+    exports.Hash = Hash;
+    function createHasher(hashCons) {
+      const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+      const tmp = hashCons();
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = () => hashCons();
+      return hashC;
+    }
+    function createOptHasher(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    function createXOFer(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    exports.wrapConstructor = createHasher;
+    exports.wrapConstructorWithOpts = createOptHasher;
+    exports.wrapXOFConstructorWithOpts = createXOFer;
+    function randomBytes(bytesLength = 32) {
+      if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+      }
+      if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
+        return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+      }
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/utils/shared.js
+var require_shared = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/utils/shared.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.equal = exports.concat = exports.HEX_REGEX = void 0;
+    var utils_1 = require_utils();
+    exports.HEX_REGEX = /^[A-F0-9]*$/iu;
+    function concat(views) {
+      return (0, utils_1.concatBytes)(...views);
+    }
+    exports.concat = concat;
+    function equal(buf1, buf2) {
+      if (buf1.byteLength !== buf2.byteLength) {
+        return false;
+      }
+      const dv1 = new Int8Array(buf1);
+      const dv2 = new Int8Array(buf2);
+      for (let i = 0; i !== buf1.byteLength; i++) {
+        if (dv1[i] !== dv2[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    exports.equal = equal;
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/utils/index.js
+var require_utils2 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/utils/index.js"(exports) {
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stringToHex = exports.hexToString = exports.randomBytes = exports.hexToBytes = exports.bytesToHex = void 0;
+    var crypto_1 = chunkOAXNH5XR_cjs.__require("crypto");
+    var shared_1 = require_shared();
+    var OriginalBuffer = Symbol("OriginalBuffer");
+    function toUint8Array(buffer) {
+      const u8Array = new Uint8Array(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+      u8Array[OriginalBuffer] = buffer;
+      return u8Array;
+    }
+    var bytesToHex = (bytes) => {
+      const buf = buffer.Buffer.from(bytes);
+      return buf.toString("hex").toUpperCase();
+    };
+    exports.bytesToHex = bytesToHex;
+    var hexToBytes = (hex) => {
+      if (!shared_1.HEX_REGEX.test(hex)) {
+        throw new Error("Invalid hex string");
+      }
+      return toUint8Array(buffer.Buffer.from(hex, "hex"));
+    };
+    exports.hexToBytes = hexToBytes;
+    var randomBytes = (size) => {
+      return toUint8Array((0, crypto_1.randomBytes)(size));
+    };
+    exports.randomBytes = randomBytes;
+    var hexToString = (hex, encoding = "utf8") => {
+      if (!shared_1.HEX_REGEX.test(hex)) {
+        throw new Error("Invalid hex string");
+      }
+      return new TextDecoder(encoding).decode((0, exports.hexToBytes)(hex));
+    };
+    exports.hexToString = hexToString;
+    var stringToHex = (string) => {
+      return (0, exports.bytesToHex)(new TextEncoder().encode(string));
+    };
+    exports.stringToHex = stringToHex;
+    __exportStar(require_shared(), exports);
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/internal/normalizeInput.js
+var require_normalizeInput = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/internal/normalizeInput.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function normalizeInput(input) {
+      return Array.isArray(input) ? new Uint8Array(input) : input;
+    }
+    exports.default = normalizeInput;
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/internal/wrapCryptoCreateHash.js
+var require_wrapCryptoCreateHash = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/internal/wrapCryptoCreateHash.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var normalizeInput_1 = __importDefault(require_normalizeInput());
+    function wrapCryptoCreateHash(type, fn) {
+      function hashFn(input) {
+        return fn(type).update((0, normalizeInput_1.default)(input)).digest();
+      }
+      hashFn.create = () => {
+        const hash = fn(type);
+        return {
+          update(input) {
+            hash.update((0, normalizeInput_1.default)(input));
+            return this;
+          },
+          digest() {
+            return hash.digest();
+          }
+        };
+      };
+      return hashFn;
+    }
+    exports.default = wrapCryptoCreateHash;
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/sha256/index.js
+var require_sha256 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/sha256/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sha256 = void 0;
+    var crypto_1 = chunkOAXNH5XR_cjs.__require("crypto");
+    var wrapCryptoCreateHash_1 = __importDefault(require_wrapCryptoCreateHash());
+    exports.sha256 = (0, wrapCryptoCreateHash_1.default)("sha256", crypto_1.createHash);
+  }
+});
+
+// node_modules/ripple-address-codec/dist/utils.js
+var require_utils3 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-address-codec/dist/utils.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.concatArgs = exports.arrayEqual = void 0;
+    function arrayEqual(arr1, arr2) {
+      if (arr1.length !== arr2.length) {
+        return false;
+      }
+      return arr1.every((value, index) => value === arr2[index]);
+    }
+    exports.arrayEqual = arrayEqual;
+    function isScalar(val) {
+      return typeof val === "number";
+    }
+    function concatArgs(...args) {
+      return args.flatMap((arg) => {
+        return isScalar(arg) ? [arg] : Array.from(arg);
+      });
+    }
+    exports.concatArgs = concatArgs;
+  }
+});
+
+// node_modules/ripple-address-codec/dist/xrp-codec.js
+var require_xrp_codec = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-address-codec/dist/xrp-codec.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isValidClassicAddress = exports.decodeAccountPublic = exports.encodeAccountPublic = exports.encodeNodePublic = exports.decodeNodePublic = exports.decodeAddress = exports.decodeAccountID = exports.encodeAddress = exports.encodeAccountID = exports.decodeSeed = exports.encodeSeed = exports.codec = void 0;
+    var base_1 = chunkOAXNH5XR_cjs.__require("@scure/base");
+    var sha256_1 = require_sha256();
+    var utils_1 = require_utils3();
+    var Codec = class {
+      constructor(options) {
+        this._sha256 = options.sha256;
+        this._codec = base_1.base58xrp;
+      }
+      /**
+       * Encoder.
+       *
+       * @param bytes - Uint8Array of data to encode.
+       * @param opts - Options object including the version bytes and the expected length of the data to encode.
+       */
+      encode(bytes, opts) {
+        const versions = opts.versions;
+        return this._encodeVersioned(bytes, versions, opts.expectedLength);
+      }
+      /**
+       * Decoder.
+       *
+       * @param base58string - Base58Check-encoded string to decode.
+       * @param opts - Options object including the version byte(s) and the expected length of the data after decoding.
+       */
+      /* eslint-disable max-lines-per-function --
+       * TODO refactor */
+      decode(base58string, opts) {
+        var _a;
+        const versions = opts.versions;
+        const types = opts.versionTypes;
+        const withoutSum = this.decodeChecked(base58string);
+        if (versions.length > 1 && !opts.expectedLength) {
+          throw new Error("expectedLength is required because there are >= 2 possible versions");
+        }
+        const versionLengthGuess = typeof versions[0] === "number" ? 1 : versions[0].length;
+        const payloadLength = (_a = opts.expectedLength) !== null && _a !== void 0 ? _a : withoutSum.length - versionLengthGuess;
+        const versionBytes = withoutSum.slice(0, -payloadLength);
+        const payload = withoutSum.slice(-payloadLength);
+        for (let i = 0; i < versions.length; i++) {
+          const version = Array.isArray(versions[i]) ? versions[i] : [versions[i]];
+          if ((0, utils_1.arrayEqual)(versionBytes, version)) {
+            return {
+              version,
+              bytes: payload,
+              type: types ? types[i] : null
+            };
+          }
+        }
+        throw new Error("version_invalid: version bytes do not match any of the provided version(s)");
+      }
+      encodeChecked(bytes) {
+        const check = this._sha256(this._sha256(bytes)).slice(0, 4);
+        return this._encodeRaw(Uint8Array.from((0, utils_1.concatArgs)(bytes, check)));
+      }
+      decodeChecked(base58string) {
+        const intArray = this._decodeRaw(base58string);
+        if (intArray.byteLength < 5) {
+          throw new Error("invalid_input_size: decoded data must have length >= 5");
+        }
+        if (!this._verifyCheckSum(intArray)) {
+          throw new Error("checksum_invalid");
+        }
+        return intArray.slice(0, -4);
+      }
+      _encodeVersioned(bytes, versions, expectedLength) {
+        if (!checkByteLength(bytes, expectedLength)) {
+          throw new Error("unexpected_payload_length: bytes.length does not match expectedLength. Ensure that the bytes are a Uint8Array.");
+        }
+        return this.encodeChecked((0, utils_1.concatArgs)(versions, bytes));
+      }
+      _encodeRaw(bytes) {
+        return this._codec.encode(Uint8Array.from(bytes));
+      }
+      /* eslint-enable max-lines-per-function */
+      _decodeRaw(base58string) {
+        return this._codec.decode(base58string);
+      }
+      _verifyCheckSum(bytes) {
+        const computed = this._sha256(this._sha256(bytes.slice(0, -4))).slice(0, 4);
+        const checksum = bytes.slice(-4);
+        return (0, utils_1.arrayEqual)(computed, checksum);
+      }
+    };
+    var ACCOUNT_ID = 0;
+    var ACCOUNT_PUBLIC_KEY = 35;
+    var FAMILY_SEED = 33;
+    var NODE_PUBLIC = 28;
+    var ED25519_SEED = [1, 225, 75];
+    var codecOptions = {
+      sha256: sha256_1.sha256
+    };
+    var codecWithXrpAlphabet = new Codec(codecOptions);
+    exports.codec = codecWithXrpAlphabet;
+    function encodeSeed(entropy, type) {
+      if (!checkByteLength(entropy, 16)) {
+        throw new Error("entropy must have length 16");
+      }
+      const opts = {
+        expectedLength: 16,
+        // for secp256k1, use `FAMILY_SEED`
+        versions: type === "ed25519" ? ED25519_SEED : [FAMILY_SEED]
+      };
+      return codecWithXrpAlphabet.encode(entropy, opts);
+    }
+    exports.encodeSeed = encodeSeed;
+    function decodeSeed(seed, opts = {
+      versionTypes: ["ed25519", "secp256k1"],
+      versions: [ED25519_SEED, FAMILY_SEED],
+      expectedLength: 16
+    }) {
+      return codecWithXrpAlphabet.decode(seed, opts);
+    }
+    exports.decodeSeed = decodeSeed;
+    function encodeAccountID(bytes) {
+      const opts = { versions: [ACCOUNT_ID], expectedLength: 20 };
+      return codecWithXrpAlphabet.encode(bytes, opts);
+    }
+    exports.encodeAccountID = encodeAccountID;
+    exports.encodeAddress = encodeAccountID;
+    function decodeAccountID(accountId) {
+      const opts = { versions: [ACCOUNT_ID], expectedLength: 20 };
+      return codecWithXrpAlphabet.decode(accountId, opts).bytes;
+    }
+    exports.decodeAccountID = decodeAccountID;
+    exports.decodeAddress = decodeAccountID;
+    function decodeNodePublic(base58string) {
+      const opts = { versions: [NODE_PUBLIC], expectedLength: 33 };
+      return codecWithXrpAlphabet.decode(base58string, opts).bytes;
+    }
+    exports.decodeNodePublic = decodeNodePublic;
+    function encodeNodePublic(bytes) {
+      const opts = { versions: [NODE_PUBLIC], expectedLength: 33 };
+      return codecWithXrpAlphabet.encode(bytes, opts);
+    }
+    exports.encodeNodePublic = encodeNodePublic;
+    function encodeAccountPublic(bytes) {
+      const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 };
+      return codecWithXrpAlphabet.encode(bytes, opts);
+    }
+    exports.encodeAccountPublic = encodeAccountPublic;
+    function decodeAccountPublic(base58string) {
+      const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 };
+      return codecWithXrpAlphabet.decode(base58string, opts).bytes;
+    }
+    exports.decodeAccountPublic = decodeAccountPublic;
+    function isValidClassicAddress(address) {
+      try {
+        decodeAccountID(address);
+      } catch (_error) {
+        return false;
+      }
+      return true;
+    }
+    exports.isValidClassicAddress = isValidClassicAddress;
+    function checkByteLength(bytes, expectedLength) {
+      return "byteLength" in bytes ? bytes.byteLength === expectedLength : bytes.length === expectedLength;
+    }
+  }
+});
+
+// node_modules/ripple-address-codec/dist/index.js
+var require_dist = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-address-codec/dist/index.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isValidXAddress = exports.decodeXAddress = exports.xAddressToClassicAddress = exports.encodeXAddress = exports.classicAddressToXAddress = exports.isValidClassicAddress = exports.decodeAccountPublic = exports.encodeAccountPublic = exports.decodeNodePublic = exports.encodeNodePublic = exports.decodeAccountID = exports.encodeAccountID = exports.decodeSeed = exports.encodeSeed = exports.codec = void 0;
+    var utils_1 = require_utils2();
+    var xrp_codec_1 = require_xrp_codec();
+    Object.defineProperty(exports, "codec", { enumerable: true, get: function() {
+      return xrp_codec_1.codec;
+    } });
+    Object.defineProperty(exports, "encodeSeed", { enumerable: true, get: function() {
+      return xrp_codec_1.encodeSeed;
+    } });
+    Object.defineProperty(exports, "decodeSeed", { enumerable: true, get: function() {
+      return xrp_codec_1.decodeSeed;
+    } });
+    Object.defineProperty(exports, "encodeAccountID", { enumerable: true, get: function() {
+      return xrp_codec_1.encodeAccountID;
+    } });
+    Object.defineProperty(exports, "decodeAccountID", { enumerable: true, get: function() {
+      return xrp_codec_1.decodeAccountID;
+    } });
+    Object.defineProperty(exports, "encodeNodePublic", { enumerable: true, get: function() {
+      return xrp_codec_1.encodeNodePublic;
+    } });
+    Object.defineProperty(exports, "decodeNodePublic", { enumerable: true, get: function() {
+      return xrp_codec_1.decodeNodePublic;
+    } });
+    Object.defineProperty(exports, "encodeAccountPublic", { enumerable: true, get: function() {
+      return xrp_codec_1.encodeAccountPublic;
+    } });
+    Object.defineProperty(exports, "decodeAccountPublic", { enumerable: true, get: function() {
+      return xrp_codec_1.decodeAccountPublic;
+    } });
+    Object.defineProperty(exports, "isValidClassicAddress", { enumerable: true, get: function() {
+      return xrp_codec_1.isValidClassicAddress;
+    } });
+    var PREFIX_BYTES = {
+      // 5, 68
+      main: Uint8Array.from([5, 68]),
+      // 4, 147
+      test: Uint8Array.from([4, 147])
+    };
+    var MAX_32_BIT_UNSIGNED_INT = 4294967295;
+    function classicAddressToXAddress(classicAddress, tag, test) {
+      const accountId = (0, xrp_codec_1.decodeAccountID)(classicAddress);
+      return encodeXAddress(accountId, tag, test);
+    }
+    exports.classicAddressToXAddress = classicAddressToXAddress;
+    function encodeXAddress(accountId, tag, test) {
+      if (accountId.length !== 20) {
+        throw new Error("Account ID must be 20 bytes");
+      }
+      if (tag !== false && tag > MAX_32_BIT_UNSIGNED_INT) {
+        throw new Error("Invalid tag");
+      }
+      const theTag = tag || 0;
+      const flag = tag === false || tag == null ? 0 : 1;
+      const bytes = (0, utils_1.concat)([
+        test ? PREFIX_BYTES.test : PREFIX_BYTES.main,
+        accountId,
+        Uint8Array.from([
+          // 0x00 if no tag, 0x01 if 32-bit tag
+          flag,
+          // first byte
+          theTag & 255,
+          // second byte
+          theTag >> 8 & 255,
+          // third byte
+          theTag >> 16 & 255,
+          // fourth byte
+          theTag >> 24 & 255,
+          0,
+          0,
+          0,
+          // four zero bytes (reserved for 64-bit tags)
+          0
+        ])
+      ]);
+      return xrp_codec_1.codec.encodeChecked(bytes);
+    }
+    exports.encodeXAddress = encodeXAddress;
+    function xAddressToClassicAddress(xAddress) {
+      const { accountId, tag, test } = decodeXAddress(xAddress);
+      const classicAddress = (0, xrp_codec_1.encodeAccountID)(accountId);
+      return {
+        classicAddress,
+        tag,
+        test
+      };
+    }
+    exports.xAddressToClassicAddress = xAddressToClassicAddress;
+    function decodeXAddress(xAddress) {
+      const decoded = xrp_codec_1.codec.decodeChecked(xAddress);
+      const test = isUint8ArrayForTestAddress(decoded);
+      const accountId = decoded.slice(2, 22);
+      const tag = tagFromUint8Array(decoded);
+      return {
+        accountId,
+        tag,
+        test
+      };
+    }
+    exports.decodeXAddress = decodeXAddress;
+    function isUint8ArrayForTestAddress(buf) {
+      const decodedPrefix = buf.slice(0, 2);
+      if ((0, utils_1.equal)(PREFIX_BYTES.main, decodedPrefix)) {
+        return false;
+      }
+      if ((0, utils_1.equal)(PREFIX_BYTES.test, decodedPrefix)) {
+        return true;
+      }
+      throw new Error("Invalid X-address: bad prefix");
+    }
+    function tagFromUint8Array(buf) {
+      const flag = buf[22];
+      if (flag >= 2) {
+        throw new Error("Unsupported X-address");
+      }
+      if (flag === 1) {
+        return buf[23] + buf[24] * 256 + buf[25] * 65536 + buf[26] * 16777216;
+      }
+      if (flag !== 0) {
+        throw new Error("flag must be zero to indicate no tag");
+      }
+      if (!(0, utils_1.equal)((0, utils_1.hexToBytes)("0000000000000000"), buf.slice(23, 23 + 8))) {
+        throw new Error("remaining bytes must be zero");
+      }
+      return false;
+    }
+    function isValidXAddress(xAddress) {
+      try {
+        decodeXAddress(xAddress);
+      } catch (_error) {
+        return false;
+      }
+      return true;
+    }
+    exports.isValidXAddress = isValidXAddress;
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/ripemd160/index.js
+var require_ripemd160 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/ripemd160/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ripemd160 = void 0;
+    var crypto_1 = chunkOAXNH5XR_cjs.__require("crypto");
+    var wrapCryptoCreateHash_1 = __importDefault(require_wrapCryptoCreateHash());
+    exports.ripemd160 = (0, wrapCryptoCreateHash_1.default)("ripemd160", crypto_1.createHash);
+  }
+});
+
+// node_modules/@xrplf/isomorphic/dist/sha512/index.js
+var require_sha512 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/@xrplf/isomorphic/dist/sha512/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sha512 = void 0;
+    var crypto_1 = chunkOAXNH5XR_cjs.__require("crypto");
+    var wrapCryptoCreateHash_1 = __importDefault(require_wrapCryptoCreateHash());
+    exports.sha512 = (0, wrapCryptoCreateHash_1.default)("sha512", crypto_1.createHash);
+  }
+});
+
+// node_modules/ripple-keypairs/dist/utils/Sha512.js
+var require_Sha512 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/utils/Sha512.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var sha512_1 = require_sha512();
+    var utils_1 = chunkOAXNH5XR_cjs.__require("@noble/curves/abstract/utils");
+    var Sha512 = class _Sha512 {
+      constructor() {
+        this.hash = sha512_1.sha512.create();
+      }
+      static half(input) {
+        return new _Sha512().add(input).first256();
+      }
+      add(bytes) {
+        this.hash.update(bytes);
+        return this;
+      }
+      addU32(i) {
+        const buffer = new Uint8Array(4);
+        new DataView(buffer.buffer).setUint32(0, i);
+        return this.add(buffer);
+      }
+      finish() {
+        return this.hash.digest();
+      }
+      first256() {
+        return this.finish().slice(0, 32);
+      }
+      first256BigInt() {
+        return (0, utils_1.bytesToNumberBE)(this.first256());
+      }
+    };
+    exports.default = Sha512;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/signing-schemes/secp256k1/utils.js
+var require_utils4 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/signing-schemes/secp256k1/utils.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.accountPublicFromPublicGenerator = exports.derivePrivateKey = void 0;
+    var secp256k1_1 = chunkOAXNH5XR_cjs.__require("@noble/curves/secp256k1");
+    var Sha512_1 = __importDefault(require_Sha512());
+    var ZERO = BigInt(0);
+    function deriveScalar(bytes, discrim) {
+      const order = secp256k1_1.secp256k1.CURVE.n;
+      for (let i = 0; i <= 4294967295; i++) {
+        const hasher = new Sha512_1.default().add(bytes);
+        if (discrim !== void 0) {
+          hasher.addU32(discrim);
+        }
+        hasher.addU32(i);
+        const key = hasher.first256BigInt();
+        if (key > ZERO && key < order) {
+          return key;
+        }
+      }
+      throw new Error("impossible unicorn ;)");
+    }
+    function derivePrivateKey(seed, opts = {}) {
+      const root = opts.validator;
+      const order = secp256k1_1.secp256k1.CURVE.n;
+      const privateGen = deriveScalar(seed);
+      if (root) {
+        return privateGen;
+      }
+      const publicGen = secp256k1_1.secp256k1.ProjectivePoint.BASE.multiply(privateGen).toRawBytes(true);
+      const accountIndex = opts.accountIndex || 0;
+      return (deriveScalar(publicGen, accountIndex) + privateGen) % order;
+    }
+    exports.derivePrivateKey = derivePrivateKey;
+    function accountPublicFromPublicGenerator(publicGenBytes) {
+      const rootPubPoint = secp256k1_1.secp256k1.ProjectivePoint.fromHex(publicGenBytes);
+      const scalar = deriveScalar(publicGenBytes, 0);
+      const point = secp256k1_1.secp256k1.ProjectivePoint.BASE.multiply(scalar);
+      const offset = rootPubPoint.add(point);
+      return offset.toRawBytes(true);
+    }
+    exports.accountPublicFromPublicGenerator = accountPublicFromPublicGenerator;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/utils/assert.js
+var require_assert = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/utils/assert.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var assertHelper = {
+      ok(cond, message) {
+        if (!cond) {
+          throw new Error(message);
+        }
+      }
+    };
+    exports.default = assertHelper;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/utils/getAlgorithmFromKey.js
+var require_getAlgorithmFromKey = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/utils/getAlgorithmFromKey.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getAlgorithmFromPrivateKey = exports.getAlgorithmFromPublicKey = exports.getAlgorithmFromKey = void 0;
+    var Prefix;
+    (function(Prefix2) {
+      Prefix2[Prefix2["NONE"] = -1] = "NONE";
+      Prefix2[Prefix2["ED25519"] = 237] = "ED25519";
+      Prefix2[Prefix2["SECP256K1_PUB_X"] = 2] = "SECP256K1_PUB_X";
+      Prefix2[Prefix2["SECP256K1_PUB_X_ODD_Y"] = 3] = "SECP256K1_PUB_X_ODD_Y";
+      Prefix2[Prefix2["SECP256K1_PUB_XY"] = 4] = "SECP256K1_PUB_XY";
+      Prefix2[Prefix2["SECP256K1_PRIVATE"] = 0] = "SECP256K1_PRIVATE";
+    })(Prefix || (Prefix = {}));
+    var KEY_TYPES = {
+      [`private_${Prefix.NONE}_32`]: "ecdsa-secp256k1",
+      [`private_${Prefix.SECP256K1_PRIVATE}_33`]: "ecdsa-secp256k1",
+      [`private_${Prefix.ED25519}_33`]: "ed25519",
+      [`public_${Prefix.ED25519}_33`]: "ed25519",
+      [`public_${Prefix.SECP256K1_PUB_X}_33`]: "ecdsa-secp256k1",
+      [`public_${Prefix.SECP256K1_PUB_X_ODD_Y}_33`]: "ecdsa-secp256k1",
+      [`public_${Prefix.SECP256K1_PUB_XY}_65`]: "ecdsa-secp256k1"
+    };
+    function getKeyInfo(key) {
+      return {
+        prefix: key.length < 2 ? Prefix.NONE : parseInt(key.slice(0, 2), 16),
+        len: key.length / 2
+      };
+    }
+    function prefixRepr(prefix) {
+      return prefix === Prefix.NONE ? "None" : `0x${prefix.toString(16).padStart(2, "0")}`;
+    }
+    function getValidFormatsTable(type) {
+      const padding = 2;
+      const colWidth = {
+        algorithm: "ecdsa-secp256k1".length + padding,
+        prefix: "0x00".length + padding
+      };
+      return Object.entries(KEY_TYPES).filter(([key]) => key.startsWith(type)).map(([key, algorithm]) => {
+        const [, prefix, length] = key.split("_");
+        const paddedAlgo = algorithm.padEnd(colWidth.algorithm);
+        const paddedPrefix = prefixRepr(Number(prefix)).padEnd(colWidth.prefix);
+        return `${paddedAlgo} - Prefix: ${paddedPrefix} Length: ${length} bytes`;
+      }).join("\n");
+    }
+    function keyError({ key, type, prefix, len }) {
+      const validFormats = getValidFormatsTable(type);
+      return `invalid_key:
+
+Type: ${type}
+Key: ${key}
+Prefix: ${prefixRepr(prefix)} 
+Length: ${len} bytes
+
+Acceptable ${type} formats are:
+${validFormats}
+`;
+    }
+    function getAlgorithmFromKey(key, type) {
+      const { prefix, len } = getKeyInfo(key);
+      const usedPrefix = type === "private" && len === 32 ? Prefix.NONE : prefix;
+      const algorithm = KEY_TYPES[`${type}_${usedPrefix}_${len}`];
+      if (!algorithm) {
+        throw new Error(keyError({ key, type, len, prefix: usedPrefix }));
+      }
+      return algorithm;
+    }
+    exports.getAlgorithmFromKey = getAlgorithmFromKey;
+    function getAlgorithmFromPublicKey(key) {
+      return getAlgorithmFromKey(key, "public");
+    }
+    exports.getAlgorithmFromPublicKey = getAlgorithmFromPublicKey;
+    function getAlgorithmFromPrivateKey(key) {
+      return getAlgorithmFromKey(key, "private");
+    }
+    exports.getAlgorithmFromPrivateKey = getAlgorithmFromPrivateKey;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/signing-schemes/secp256k1/index.js
+var require_secp256k1 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/signing-schemes/secp256k1/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var utils_1 = chunkOAXNH5XR_cjs.__require("@noble/curves/abstract/utils");
+    var secp256k1_1 = chunkOAXNH5XR_cjs.__require("@noble/curves/secp256k1");
+    var utils_2 = require_utils2();
+    var utils_3 = require_utils4();
+    var assert_1 = __importDefault(require_assert());
+    var Sha512_1 = __importDefault(require_Sha512());
+    var SECP256K1_PREFIX = "00";
+    var secp256k1 = {
+      deriveKeypair(entropy, options) {
+        const derived = (0, utils_3.derivePrivateKey)(entropy, options);
+        const privateKey = SECP256K1_PREFIX + (0, utils_2.bytesToHex)((0, utils_1.numberToBytesBE)(derived, 32));
+        const publicKey = (0, utils_2.bytesToHex)(secp256k1_1.secp256k1.getPublicKey(derived, true));
+        return { privateKey, publicKey };
+      },
+      sign(message, privateKey) {
+        assert_1.default.ok(privateKey.length === 66 && privateKey.startsWith(SECP256K1_PREFIX) || privateKey.length === 64);
+        const normedPrivateKey = privateKey.length === 66 ? privateKey.slice(2) : privateKey;
+        return secp256k1_1.secp256k1.sign(Sha512_1.default.half(message), normedPrivateKey, {
+          // "Canonical" signatures
+          lowS: true,
+          // Would fail tests if signatures aren't deterministic
+          extraEntropy: void 0
+        }).toDERHex(true).toUpperCase();
+      },
+      verify(message, signature, publicKey) {
+        const decoded = secp256k1_1.secp256k1.Signature.fromDER(signature);
+        return secp256k1_1.secp256k1.verify(decoded, Sha512_1.default.half(message), publicKey);
+      }
+    };
+    exports.default = secp256k1;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/signing-schemes/ed25519/index.js
+var require_ed25519 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/signing-schemes/ed25519/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ed25519_1 = chunkOAXNH5XR_cjs.__require("@noble/curves/ed25519");
+    var utils_1 = require_utils2();
+    var assert_1 = __importDefault(require_assert());
+    var Sha512_1 = __importDefault(require_Sha512());
+    var ED_PREFIX = "ED";
+    var ed25519 = {
+      deriveKeypair(entropy) {
+        const rawPrivateKey = Sha512_1.default.half(entropy);
+        const privateKey = ED_PREFIX + (0, utils_1.bytesToHex)(rawPrivateKey);
+        const publicKey = ED_PREFIX + (0, utils_1.bytesToHex)(ed25519_1.ed25519.getPublicKey(rawPrivateKey));
+        return { privateKey, publicKey };
+      },
+      sign(message, privateKey) {
+        assert_1.default.ok(message instanceof Uint8Array, "message must be array of octets");
+        assert_1.default.ok(privateKey.length === 66, "private key must be 33 bytes including prefix");
+        return (0, utils_1.bytesToHex)(ed25519_1.ed25519.sign(message, privateKey.slice(2)));
+      },
+      verify(message, signature, publicKey) {
+        assert_1.default.ok(publicKey.length === 66, "public key must be 33 bytes including prefix");
+        return ed25519_1.ed25519.verify(
+          signature,
+          message,
+          // Remove the 0xED prefix
+          publicKey.slice(2),
+          // By default, set zip215 to false for compatibility reasons.
+          // ZIP 215 is a stricter Ed25519 signature verification scheme.
+          // However, setting it to false adheres to the more commonly used
+          // RFC8032 / NIST186-5 standards, making it compatible with systems
+          // like the XRP Ledger.
+          { zip215: false }
+        );
+      }
+    };
+    exports.default = ed25519;
+  }
+});
+
+// node_modules/ripple-keypairs/dist/index.js
+var require_dist2 = chunkOAXNH5XR_cjs.__commonJS({
+  "node_modules/ripple-keypairs/dist/index.js"(exports) {
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodeSeed = exports.deriveNodeAddress = exports.deriveAddress = exports.verify = exports.sign = exports.deriveKeypair = exports.generateSeed = void 0;
+    var ripple_address_codec_1 = require_dist();
+    Object.defineProperty(exports, "decodeSeed", { enumerable: true, get: function() {
+      return ripple_address_codec_1.decodeSeed;
+    } });
+    var ripemd160_1 = require_ripemd160();
+    var sha256_1 = require_sha256();
+    var utils_1 = require_utils2();
+    var utils_2 = require_utils4();
+    var Sha512_1 = __importDefault(require_Sha512());
+    var assert_1 = __importDefault(require_assert());
+    var getAlgorithmFromKey_1 = require_getAlgorithmFromKey();
+    var secp256k1_1 = __importDefault(require_secp256k1());
+    var ed25519_1 = __importDefault(require_ed25519());
+    function getSigningScheme(algorithm) {
+      const schemes = { "ecdsa-secp256k1": secp256k1_1.default, ed25519: ed25519_1.default };
+      return schemes[algorithm];
+    }
+    function generateSeed(options = {}) {
+      assert_1.default.ok(!options.entropy || options.entropy.length >= 16, "entropy too short");
+      const entropy = options.entropy ? options.entropy.slice(0, 16) : (0, utils_1.randomBytes)(16);
+      const type = options.algorithm === "ed25519" ? "ed25519" : "secp256k1";
+      return (0, ripple_address_codec_1.encodeSeed)(entropy, type);
+    }
+    exports.generateSeed = generateSeed;
+    function deriveKeypair(seed, options) {
+      var _a;
+      const decoded = (0, ripple_address_codec_1.decodeSeed)(seed);
+      const proposedAlgorithm = (_a = options === null || options === void 0 ? void 0 : options.algorithm) !== null && _a !== void 0 ? _a : decoded.type;
+      const algorithm = proposedAlgorithm === "ed25519" ? "ed25519" : "ecdsa-secp256k1";
+      const scheme = getSigningScheme(algorithm);
+      const keypair = scheme.deriveKeypair(decoded.bytes, options);
+      const messageToVerify = Sha512_1.default.half("This test message should verify.");
+      const signature = scheme.sign(messageToVerify, keypair.privateKey);
+      if (!scheme.verify(messageToVerify, signature, keypair.publicKey)) {
+        throw new Error("derived keypair did not generate verifiable signature");
+      }
+      return keypair;
+    }
+    exports.deriveKeypair = deriveKeypair;
+    function sign(messageHex, privateKey) {
+      const algorithm = (0, getAlgorithmFromKey_1.getAlgorithmFromPrivateKey)(privateKey);
+      return getSigningScheme(algorithm).sign((0, utils_1.hexToBytes)(messageHex), privateKey);
+    }
+    exports.sign = sign;
+    function verify2(messageHex, signature, publicKey) {
+      const algorithm = (0, getAlgorithmFromKey_1.getAlgorithmFromPublicKey)(publicKey);
+      return getSigningScheme(algorithm).verify((0, utils_1.hexToBytes)(messageHex), signature, publicKey);
+    }
+    exports.verify = verify2;
+    function computePublicKeyHash(publicKeyBytes) {
+      return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(publicKeyBytes));
+    }
+    function deriveAddressFromBytes(publicKeyBytes) {
+      return (0, ripple_address_codec_1.encodeAccountID)(computePublicKeyHash(publicKeyBytes));
+    }
+    function deriveAddress(publicKey) {
+      return deriveAddressFromBytes((0, utils_1.hexToBytes)(publicKey));
+    }
+    exports.deriveAddress = deriveAddress;
+    function deriveNodeAddress(publicKey) {
+      const generatorBytes = (0, ripple_address_codec_1.decodeNodePublic)(publicKey);
+      const accountPublicBytes = (0, utils_2.accountPublicFromPublicGenerator)(generatorBytes);
+      return deriveAddressFromBytes(accountPublicBytes);
+    }
+    exports.deriveNodeAddress = deriveNodeAddress;
+  }
+});
+
+// src/xrpl.ts
+var import_ripple_keypairs = chunkOAXNH5XR_cjs.__toESM(require_dist2(), 1);
+function verifyXRPL(message, publicKey, proof) {
+  return (0, import_ripple_keypairs.verify)(buffer.Buffer.from(message).toString("hex"), proof, publicKey);
+}
+var xrplTestnetWs = [
+  "wss://s.altnet.rippletest.net:51233",
+  "wss://testnet.xrpl-labs.com/"
+];
+var xrplMainnetWs = [
+  "wss://s1.ripple.com",
+  "wss://xrplcluster.com/",
+  // full node
+  "wss://s2.ripple.com/"
+];
+async function getPublicKey(address, isTest) {
+  const servers = isTest ? xrplTestnetWs : xrplMainnetWs;
+  for (const server of servers) {
+    try {
+      const client = new xrpl.Client(server);
+      await client.connect();
+      const response = await client.request({
+        command: "account_tx",
+        account: address,
+        binary: false,
+        limit: 2,
+        forward: false
+      });
+      await client.disconnect();
+      return getSigningPubkeyFromLatestTx(response.result?.transactions);
+    } catch (error) {
+      let errorMessage = "Connection to XRPL server failed";
+      if (error instanceof Error) {
+        errorMessage += `: ${error.message}`;
+      }
+      console.error(errorMessage);
+    }
+  }
+}
+function getSigningPubkeyFromLatestTx(latestTx) {
+  for (let i = 0; i < latestTx.length; i++) {
+    const signingPubKey = latestTx[i]?.tx_json?.SigningPubKey ?? "0x";
+    return signingPubKey;
+  }
+  throw new Error("No valid pubkey found in the latest transactions");
+}
+async function verifyPersonalSignXRPL(proof, publicKey, isTest) {
+  const [ns, , address] = proof.address.split(/:/);
+  if (ns !== "xrpl") return { ...proof, status: javascriptSdk.ProofStatus.FAILED };
+  if (!publicKey) {
+    publicKey = await getPublicKey(address, isTest);
+  }
+  if (!publicKey) {
+    return { ...proof, status: javascriptSdk.ProofStatus.FAILED };
+  }
+  const verified = verifyXRPL(proof.attestation, publicKey, proof.proof);
+  return {
+    ...proof,
+    status: verified ? javascriptSdk.ProofStatus.VERIFIED : javascriptSdk.ProofStatus.FAILED
+  };
+}
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+
+exports.verifyPersonalSignXRPL = verifyPersonalSignXRPL;
+exports.verifyXRPL = verifyXRPL;
+exports.xrplMainnetWs = xrplMainnetWs;
+exports.xrplTestnetWs = xrplTestnetWs;
+//# sourceMappingURL=xrpl-7HQLIDAK.cjs.map
+//# sourceMappingURL=xrpl-7HQLIDAK.cjs.map