@vleap/warps-adapter-fastset 0.1.0-beta.46 → 0.1.0-beta.48

package/dist/index.mjs

@@ -1,9 +1,5 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/main.ts
@@ -20,9 +16,6 @@ function uint8ArrayToHex(uint8Array) {
 function hexToUint8Array(hex) {
   return new Uint8Array(Buffer.from(hex, "hex"));
 }
-function stringToUint8Array(str) {
-  return new Uint8Array(Buffer.from(str, "utf8"));
-}
 
 // src/helpers/general.ts
 import { getProviderConfig } from "@vleap/warps";
@@ -1705,8 +1698,8 @@ var WarpFastsetExplorer = class {
   getAccountUrl(address) {
     return `${this.explorerUrl}/account/${address}`;
   }
-  getTransactionUrl(hash2) {
-    return `${this.explorerUrl}/txs/${HEX_PREFIX}${hash2}`;
+  getTransactionUrl(hash) {
+    return `${this.explorerUrl}/txs/${HEX_PREFIX}${hash}`;
   }
   getAssetUrl(identifier) {
     return `${this.explorerUrl}/asset/${HEX_PREFIX}${identifier}`;
@@ -1936,555 +1929,24 @@ var WarpFastsetOutput = class {
 };
 
 // src/WarpFastsetWallet.ts
-import * as bip39 from "@scure/bip39";
 import {
-  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3,
-  getWarpWalletPrivateKeyFromConfig
+  initializeWalletCache
 } from "@vleap/warps";
 
-// ../../node_modules/@noble/ed25519/index.js
-var ed25519_exports = {};
-__export(ed25519_exports, {
-  Point: () => Point,
-  etc: () => etc,
-  getPublicKey: () => getPublicKey,
-  getPublicKeyAsync: () => getPublicKeyAsync,
-  hash: () => hash,
-  hashes: () => hashes,
-  keygen: () => keygen,
-  keygenAsync: () => keygenAsync,
-  sign: () => sign,
-  signAsync: () => signAsync,
-  utils: () => utils,
-  verify: () => verify,
-  verifyAsync: () => verifyAsync
-});
-var ed25519_CURVE = {
-  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
-  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
-  h: 8n,
-  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
-  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
-  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
-  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
-};
-var { p: P, n: N, Gx, Gy, a: _a, d: _d, h } = ed25519_CURVE;
-var L = 32;
-var L2 = 64;
-var captureTrace = (...args) => {
-  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
-    Error.captureStackTrace(...args);
-  }
-};
-var err = (message = "") => {
-  const e = new Error(message);
-  captureTrace(e, err);
-  throw e;
-};
-var isBig = (n) => typeof n === "bigint";
-var isStr = (s) => typeof s === "string";
-var isBytes2 = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-var abytes = (value, length, title = "") => {
-  const bytes = isBytes2(value);
-  const len = value?.length;
-  const needsLen = length !== void 0;
-  if (!bytes || needsLen && len !== length) {
-    const prefix = title && `"${title}" `;
-    const ofLen = needsLen ? ` of length ${length}` : "";
-    const got = bytes ? `length=${len}` : `type=${typeof value}`;
-    err(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-  }
-  return value;
-};
-var u8n = (len) => new Uint8Array(len);
-var u8fr = (buf) => Uint8Array.from(buf);
-var padh = (n, pad) => n.toString(16).padStart(pad, "0");
-var bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
-var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-var _ch = (ch) => {
-  if (ch >= C._0 && ch <= C._9)
-    return ch - C._0;
-  if (ch >= C.A && ch <= C.F)
-    return ch - (C.A - 10);
-  if (ch >= C.a && ch <= C.f)
-    return ch - (C.a - 10);
-  return;
-};
-var hexToBytes = (hex) => {
-  const e = "hex invalid";
-  if (!isStr(hex))
-    return err(e);
-  const hl = hex.length;
-  const al = hl / 2;
-  if (hl % 2)
-    return err(e);
-  const array = u8n(al);
-  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-    const n1 = _ch(hex.charCodeAt(hi));
-    const n2 = _ch(hex.charCodeAt(hi + 1));
-    if (n1 === void 0 || n2 === void 0)
-      return err(e);
-    array[ai] = n1 * 16 + n2;
-  }
-  return array;
-};
-var cr = () => globalThis?.crypto;
-var subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined, consider polyfill");
-var concatBytes = (...arrs) => {
-  const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
-  let pad = 0;
-  arrs.forEach((a) => {
-    r.set(a, pad);
-    pad += a.length;
-  });
-  return r;
-};
-var randomBytes = (len = L) => {
-  const c = cr();
-  return c.getRandomValues(u8n(len));
-};
-var big = BigInt;
-var assertRange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
-var M = (a, b = P) => {
-  const r = a % b;
-  return r >= 0n ? r : b + r;
-};
-var modN = (a) => M(a, N);
-var invert = (num, md) => {
-  if (num === 0n || md <= 0n)
-    err("no inverse n=" + num + " mod=" + md);
-  let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
-  while (a !== 0n) {
-    const q = b / a, r = b % a;
-    const m = x - u * q, n = y - v * q;
-    b = a, a = r, x = u, y = v, u = m, v = n;
-  }
-  return b === 1n ? M(x, md) : err("no inverse");
-};
-var callHash = (name) => {
-  const fn = hashes[name];
-  if (typeof fn !== "function")
-    err("hashes." + name + " not set");
-  return fn;
-};
-var hash = (msg) => callHash("sha512")(msg);
-var apoint = (p) => p instanceof Point ? p : err("Point expected");
-var B256 = 2n ** 256n;
-var _Point = class _Point {
-  constructor(X, Y, Z, T) {
-    __publicField(this, "X");
-    __publicField(this, "Y");
-    __publicField(this, "Z");
-    __publicField(this, "T");
-    const max = B256;
-    this.X = assertRange(X, 0n, max);
-    this.Y = assertRange(Y, 0n, max);
-    this.Z = assertRange(Z, 1n, max);
-    this.T = assertRange(T, 0n, max);
-    Object.freeze(this);
-  }
-  static CURVE() {
-    return ed25519_CURVE;
-  }
-  static fromAffine(p) {
-    return new _Point(p.x, p.y, 1n, M(p.x * p.y));
-  }
-  /** RFC8032 5.1.3: Uint8Array to Point. */
-  static fromBytes(hex, zip215 = false) {
-    const d = _d;
-    const normed = u8fr(abytes(hex, L));
-    const lastByte = hex[31];
-    normed[31] = lastByte & ~128;
-    const y = bytesToNumLE(normed);
-    const max = zip215 ? B256 : P;
-    assertRange(y, 0n, max);
-    const y2 = M(y * y);
-    const u = M(y2 - 1n);
-    const v = M(d * y2 + 1n);
-    let { isValid, value: x } = uvRatio(u, v);
-    if (!isValid)
-      err("bad point: y not sqrt");
-    const isXOdd = (x & 1n) === 1n;
-    const isLastByteOdd = (lastByte & 128) !== 0;
-    if (!zip215 && x === 0n && isLastByteOdd)
-      err("bad point: x==0, isLastByteOdd");
-    if (isLastByteOdd !== isXOdd)
-      x = M(-x);
-    return new _Point(x, y, 1n, M(x * y));
-  }
-  static fromHex(hex, zip215) {
-    return _Point.fromBytes(hexToBytes(hex), zip215);
-  }
-  get x() {
-    return this.toAffine().x;
-  }
-  get y() {
-    return this.toAffine().y;
-  }
-  /** Checks if the point is valid and on-curve. */
-  assertValidity() {
-    const a = _a;
-    const d = _d;
-    const p = this;
-    if (p.is0())
-      return err("bad point: ZERO");
-    const { X, Y, Z, T } = p;
-    const X2 = M(X * X);
-    const Y2 = M(Y * Y);
-    const Z2 = M(Z * Z);
-    const Z4 = M(Z2 * Z2);
-    const aX2 = M(X2 * a);
-    const left = M(Z2 * M(aX2 + Y2));
-    const right = M(Z4 + M(d * M(X2 * Y2)));
-    if (left !== right)
-      return err("bad point: equation left != right (1)");
-    const XY = M(X * Y);
-    const ZT = M(Z * T);
-    if (XY !== ZT)
-      return err("bad point: equation left != right (2)");
-    return this;
-  }
-  /** Equality check: compare points P&Q. */
-  equals(other) {
-    const { X: X1, Y: Y1, Z: Z1 } = this;
-    const { X: X2, Y: Y2, Z: Z2 } = apoint(other);
-    const X1Z2 = M(X1 * Z2);
-    const X2Z1 = M(X2 * Z1);
-    const Y1Z2 = M(Y1 * Z2);
-    const Y2Z1 = M(Y2 * Z1);
-    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
-  }
-  is0() {
-    return this.equals(I);
-  }
-  /** Flip point over y coordinate. */
-  negate() {
-    return new _Point(M(-this.X), this.Y, this.Z, M(-this.T));
-  }
-  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
-  double() {
-    const { X: X1, Y: Y1, Z: Z1 } = this;
-    const a = _a;
-    const A = M(X1 * X1);
-    const B = M(Y1 * Y1);
-    const C2 = M(2n * M(Z1 * Z1));
-    const D = M(a * A);
-    const x1y1 = X1 + Y1;
-    const E = M(M(x1y1 * x1y1) - A - B);
-    const G2 = D + B;
-    const F = G2 - C2;
-    const H = D - B;
-    const X3 = M(E * F);
-    const Y3 = M(G2 * H);
-    const T3 = M(E * H);
-    const Z3 = M(F * G2);
-    return new _Point(X3, Y3, Z3, T3);
-  }
-  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
-  add(other) {
-    const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
-    const { X: X2, Y: Y2, Z: Z2, T: T2 } = apoint(other);
-    const a = _a;
-    const d = _d;
-    const A = M(X1 * X2);
-    const B = M(Y1 * Y2);
-    const C2 = M(T1 * d * T2);
-    const D = M(Z1 * Z2);
-    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
-    const F = M(D - C2);
-    const G2 = M(D + C2);
-    const H = M(B - a * A);
-    const X3 = M(E * F);
-    const Y3 = M(G2 * H);
-    const T3 = M(E * H);
-    const Z3 = M(F * G2);
-    return new _Point(X3, Y3, Z3, T3);
-  }
-  subtract(other) {
-    return this.add(apoint(other).negate());
-  }
-  /**
-   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
-   * Uses {@link wNAF} for base point.
-   * Uses fake point to mitigate side-channel leakage.
-   * @param n scalar by which point is multiplied
-   * @param safe safe mode guards against timing attacks; unsafe mode is faster
-   */
-  multiply(n, safe = true) {
-    if (!safe && (n === 0n || this.is0()))
-      return I;
-    assertRange(n, 1n, N);
-    if (n === 1n)
-      return this;
-    if (this.equals(G))
-      return wNAF(n).p;
-    let p = I;
-    let f = G;
-    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
-      if (n & 1n)
-        p = p.add(d);
-      else if (safe)
-        f = f.add(d);
-    }
-    return p;
-  }
-  multiplyUnsafe(scalar) {
-    return this.multiply(scalar, false);
-  }
-  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
-  toAffine() {
-    const { X, Y, Z } = this;
-    if (this.equals(I))
-      return { x: 0n, y: 1n };
-    const iz = invert(Z, P);
-    if (M(Z * iz) !== 1n)
-      err("invalid inverse");
-    const x = M(X * iz);
-    const y = M(Y * iz);
-    return { x, y };
-  }
-  toBytes() {
-    const { x, y } = this.assertValidity().toAffine();
-    const b = numTo32bLE(y);
-    b[31] |= x & 1n ? 128 : 0;
-    return b;
-  }
-  toHex() {
-    return bytesToHex(this.toBytes());
-  }
-  clearCofactor() {
-    return this.multiply(big(h), false);
-  }
-  isSmallOrder() {
-    return this.clearCofactor().is0();
-  }
-  isTorsionFree() {
-    let p = this.multiply(N / 2n, false).double();
-    if (N % 2n)
-      p = p.add(this);
-    return p.is0();
-  }
-};
-__publicField(_Point, "BASE");
-__publicField(_Point, "ZERO");
-var Point = _Point;
-var G = new Point(Gx, Gy, 1n, M(Gx * Gy));
-var I = new Point(0n, 1n, 1n, 0n);
-Point.BASE = G;
-Point.ZERO = I;
-var numTo32bLE = (num) => hexToBytes(padh(assertRange(num, 0n, B256), L2)).reverse();
-var bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
-var pow2 = (x, power) => {
-  let r = x;
-  while (power-- > 0n) {
-    r *= r;
-    r %= P;
-  }
-  return r;
-};
-var pow_2_252_3 = (x) => {
-  const x2 = x * x % P;
-  const b2 = x2 * x % P;
-  const b4 = pow2(b2, 2n) * b2 % P;
-  const b5 = pow2(b4, 1n) * x % P;
-  const b10 = pow2(b5, 5n) * b5 % P;
-  const b20 = pow2(b10, 10n) * b10 % P;
-  const b40 = pow2(b20, 20n) * b20 % P;
-  const b80 = pow2(b40, 40n) * b40 % P;
-  const b160 = pow2(b80, 80n) * b80 % P;
-  const b240 = pow2(b160, 80n) * b80 % P;
-  const b250 = pow2(b240, 10n) * b10 % P;
-  const pow_p_5_8 = pow2(b250, 2n) * x % P;
-  return { pow_p_5_8, b2 };
-};
-var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
-var uvRatio = (u, v) => {
-  const v3 = M(v * v * v);
-  const v7 = M(v3 * v3 * v);
-  const pow = pow_2_252_3(u * v7).pow_p_5_8;
-  let x = M(u * v3 * pow);
-  const vx2 = M(v * x * x);
-  const root1 = x;
-  const root2 = M(x * RM1);
-  const useRoot1 = vx2 === u;
-  const useRoot2 = vx2 === M(-u);
-  const noRoot = vx2 === M(-u * RM1);
-  if (useRoot1)
-    x = root1;
-  if (useRoot2 || noRoot)
-    x = root2;
-  if ((M(x) & 1n) === 1n)
-    x = M(-x);
-  return { isValid: useRoot1 || useRoot2, value: x };
-};
-var modL_LE = (hash2) => modN(bytesToNumLE(hash2));
-var sha512a = (...m) => hashes.sha512Async(concatBytes(...m));
-var sha512s = (...m) => callHash("sha512")(concatBytes(...m));
-var hash2extK = (hashed) => {
-  const head = hashed.slice(0, L);
-  head[0] &= 248;
-  head[31] &= 127;
-  head[31] |= 64;
-  const prefix = hashed.slice(L, L2);
-  const scalar = modL_LE(head);
-  const point = G.multiply(scalar);
-  const pointBytes = point.toBytes();
-  return { head, prefix, scalar, point, pointBytes };
-};
-var getExtendedPublicKeyAsync = (secretKey) => sha512a(abytes(secretKey, L)).then(hash2extK);
-var getExtendedPublicKey = (secretKey) => hash2extK(sha512s(abytes(secretKey, L)));
-var getPublicKeyAsync = (secretKey) => getExtendedPublicKeyAsync(secretKey).then((p) => p.pointBytes);
-var getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
-var hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
-var hashFinishS = (res) => res.finish(sha512s(res.hashable));
-var _sign = (e, rBytes, msg) => {
-  const { pointBytes: P2, scalar: s } = e;
-  const r = modL_LE(rBytes);
-  const R = G.multiply(r).toBytes();
-  const hashable = concatBytes(R, P2, msg);
-  const finish = (hashed) => {
-    const S = modN(r + modL_LE(hashed) * s);
-    return abytes(concatBytes(R, numTo32bLE(S)), L2);
-  };
-  return { hashable, finish };
-};
-var signAsync = async (message, secretKey) => {
-  const m = abytes(message);
-  const e = await getExtendedPublicKeyAsync(secretKey);
-  const rBytes = await sha512a(e.prefix, m);
-  return hashFinishA(_sign(e, rBytes, m));
-};
-var sign = (message, secretKey) => {
-  const m = abytes(message);
-  const e = getExtendedPublicKey(secretKey);
-  const rBytes = sha512s(e.prefix, m);
-  return hashFinishS(_sign(e, rBytes, m));
-};
-var defaultVerifyOpts = { zip215: true };
-var _verify = (sig, msg, pub, opts = defaultVerifyOpts) => {
-  sig = abytes(sig, L2);
-  msg = abytes(msg);
-  pub = abytes(pub, L);
-  const { zip215 } = opts;
-  let A;
-  let R;
-  let s;
-  let SB;
-  let hashable = Uint8Array.of();
-  try {
-    A = Point.fromBytes(pub, zip215);
-    R = Point.fromBytes(sig.slice(0, L), zip215);
-    s = bytesToNumLE(sig.slice(L, L2));
-    SB = G.multiply(s, false);
-    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
-  } catch (error) {
-  }
-  const finish = (hashed) => {
-    if (SB == null)
-      return false;
-    if (!zip215 && A.isSmallOrder())
-      return false;
-    const k = modL_LE(hashed);
-    const RkA = R.add(A.multiply(k, false));
-    return RkA.add(SB.negate()).clearCofactor().is0();
-  };
-  return { hashable, finish };
-};
-var verifyAsync = async (signature, message, publicKey, opts = defaultVerifyOpts) => hashFinishA(_verify(signature, message, publicKey, opts));
-var verify = (signature, message, publicKey, opts = defaultVerifyOpts) => hashFinishS(_verify(signature, message, publicKey, opts));
-var etc = {
-  bytesToHex,
-  hexToBytes,
-  concatBytes,
-  mod: M,
-  invert,
-  randomBytes
-};
-var hashes = {
-  sha512Async: async (message) => {
-    const s = subtle();
-    const m = concatBytes(message);
-    return u8n(await s.digest("SHA-512", m.buffer));
-  },
-  sha512: void 0
-};
-var randomSecretKey = (seed = randomBytes(L)) => seed;
-var keygen = (seed) => {
-  const secretKey = randomSecretKey(seed);
-  const publicKey = getPublicKey(secretKey);
-  return { secretKey, publicKey };
-};
-var keygenAsync = async (seed) => {
-  const secretKey = randomSecretKey(seed);
-  const publicKey = await getPublicKeyAsync(secretKey);
-  return { secretKey, publicKey };
-};
-var utils = {
-  getExtendedPublicKeyAsync,
-  getExtendedPublicKey,
-  randomSecretKey
-};
-var W = 8;
-var scalarBits = 256;
-var pwindows = Math.ceil(scalarBits / W) + 1;
-var pwindowSize = 2 ** (W - 1);
-var precompute = () => {
-  const points = [];
-  let p = G;
-  let b = p;
-  for (let w = 0; w < pwindows; w++) {
-    b = p;
-    points.push(b);
-    for (let i = 1; i < pwindowSize; i++) {
-      b = b.add(p);
-      points.push(b);
-    }
-    p = b.double();
-  }
-  return points;
-};
-var Gpows = void 0;
-var ctneg = (cnd, p) => {
-  const n = p.negate();
-  return cnd ? n : p;
-};
-var wNAF = (n) => {
-  const comp = Gpows || (Gpows = precompute());
-  let p = I;
-  let f = G;
-  const pow_2_w = 2 ** W;
-  const maxNum = pow_2_w;
-  const mask = big(pow_2_w - 1);
-  const shiftBy = big(W);
-  for (let w = 0; w < pwindows; w++) {
-    let wbits = Number(n & mask);
-    n >>= shiftBy;
-    if (wbits > pwindowSize) {
-      wbits -= maxNum;
-      n += 1n;
-    }
-    const off = w * pwindowSize;
-    const offF = off;
-    const offP = off + Math.abs(wbits) - 1;
-    const isEven = w % 2 !== 0;
-    const isNeg = wbits < 0;
-    if (wbits === 0) {
-      f = f.add(ctneg(isEven, comp[offF]));
-    } else {
-      p = p.add(ctneg(isNeg, comp[offP]));
-    }
-  }
-  if (n !== 0n)
-    err("invalid wnaf");
-  return { p, f };
-};
+// src/providers/MnemonicWalletProvider.ts
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { getWarpWalletMnemonicFromConfig } from "@vleap/warps";
+
+// src/sdk/ed25519-setup.ts
+import * as ed25519 from "@noble/ed25519";
 
-// node_modules/@noble/hashes/utils.js
-function isBytes3(a) {
+// ../../node_modules/@noble/hashes/utils.js
+function isBytes2(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function abytes2(value, length, title = "") {
-  const bytes = isBytes3(value);
+function abytes(value, length, title = "") {
+  const bytes = isBytes2(value);
   const len = value?.length;
   const needsLen = length !== void 0;
   if (!bytes || needsLen && len !== length) {
@@ -2502,7 +1964,7 @@ function aexists(instance, checkFinished = true) {
     throw new Error("Hash#digest() has already been called");
 }
 function aoutput(out, instance) {
-  abytes2(out, void 0, "digestInto() output");
+  abytes(out, void 0, "digestInto() output");
   const min = instance.outputLen;
   if (out.length < min) {
     throw new Error('"digestInto() output" expected to be of length >=' + min);
@@ -2529,7 +1991,7 @@ var oidNist = (suffix) => ({
   oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
 });
 
-// node_modules/@noble/hashes/_md.js
+// ../../node_modules/@noble/hashes/_md.js
 var HashMD = class {
   constructor(blockLen, outputLen, padOffset, isLE) {
     __publicField(this, "blockLen");
@@ -2552,7 +2014,7 @@ var HashMD = class {
   }
   update(data) {
     aexists(this);
-    abytes2(data);
+    abytes(data);
     const { view, buffer, blockLen } = this;
     const len = data.length;
     for (let pos = 0; pos < len; ) {
@@ -2644,7 +2106,7 @@ var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
   327033209
 ]);
 
-// node_modules/@noble/hashes/_u64.js
+// ../../node_modules/@noble/hashes/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n = /* @__PURE__ */ BigInt(32);
 function fromBig(n, le = false) {
@@ -2657,17 +2119,17 @@ function split(lst, le = false) {
   let Ah = new Uint32Array(len);
   let Al = new Uint32Array(len);
   for (let i = 0; i < len; i++) {
-    const { h: h2, l } = fromBig(lst[i], le);
-    [Ah[i], Al[i]] = [h2, l];
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
   }
   return [Ah, Al];
 }
-var shrSH = (h2, _l, s) => h2 >>> s;
-var shrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
-var rotrSH = (h2, l, s) => h2 >>> s | l << 32 - s;
-var rotrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
-var rotrBH = (h2, l, s) => h2 << 64 - s | l >>> s - 32;
-var rotrBL = (h2, l, s) => h2 >>> s - 32 | l << 64 - s;
+var shrSH = (h, _l, s) => h >>> s;
+var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
 function add(Ah, Al, Bh, Bl) {
   const l = (Al >>> 0) + (Bl >>> 0);
   return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
@@ -2679,7 +2141,7 @@ var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0
 var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
 var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
 
-// node_modules/@noble/hashes/sha2.js
+// ../../node_modules/@noble/hashes/sha2.js
 var K512 = /* @__PURE__ */ (() => split([
   "0x428a2f98d728ae22",
   "0x7137449123ef65cd",
@@ -2888,38 +2350,216 @@ var sha512 = /* @__PURE__ */ createHasher(
 );
 
 // src/sdk/ed25519-setup.ts
-hashes.sha512 = sha512;
+ed25519.hashes.sha512 = sha512;
+var ed = ed25519;
 
-// src/WarpFastsetWallet.ts
-var WarpFastsetWallet = class {
+// src/providers/MnemonicWalletProvider.ts
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
   constructor(config, chain2) {
     this.config = config;
     this.chain = chain2;
-    this.client = getConfiguredFastsetClient(this.config, this.chain);
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
+    } catch {
+      return null;
+    }
   }
   async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
     const msg = Transaction.serialize(tx);
     const msgBytes = msg.toBytes();
     const prefix = new TextEncoder().encode("Transaction::");
     const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
     dataToSign.set(prefix, 0);
     dataToSign.set(msgBytes, prefix.length);
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
-    const privateKeyBytes = hexToUint8Array(privateKey);
-    const signature = ed25519_exports.sign(dataToSign, privateKeyBytes);
+    const signature = ed.sign(dataToSign, privateKey);
     return { ...tx, signature };
   }
   async signMessage(message) {
-    const messageBytes = stringToUint8Array(message);
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
-    const privateKeyBytes = hexToUint8Array(privateKey);
-    const signature = ed25519_exports.sign(messageBytes, privateKeyBytes);
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
     return uint8ArrayToHex(signature);
   }
+  create(mnemonic) {
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  generate() {
+    const mnemonic = bip39.generateMnemonic(wordlist);
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.privateKey = seed.slice(0, 32);
+    return this.privateKey;
+  }
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/PrivateKeyWalletProvider.ts
+import { getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
+    const msg = Transaction.serialize(tx);
+    const msgBytes = msg.toBytes();
+    const prefix = new TextEncoder().encode("Transaction::");
+    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
+    dataToSign.set(prefix, 0);
+    dataToSign.set(msgBytes, prefix.length);
+    const signature = ed.sign(dataToSign, privateKey);
+    return { ...tx, signature };
+  }
+  async signMessage(message) {
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
+    return uint8ArrayToHex(signature);
+  }
+  create(mnemonic) {
+    throw new Error("PrivateKeyWalletProvider does not support creating wallets from mnemonics. Use MnemonicWalletProvider instead.");
+  }
+  generate() {
+    const privateKey = ed.utils.randomSecretKey();
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: uint8ArrayToHex(privateKey),
+      mnemonic: null
+    };
+  }
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const privateKeyHex = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (!privateKeyHex) throw new Error("No private key provided");
+    this.privateKey = hexToUint8Array(privateKeyHex);
+    return this.privateKey;
+  }
+};
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
+
+// src/providers/ReadOnlyWalletProvider.ts
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3 } from "@vleap/warps";
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+  }
+  async getAddress() {
+    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async signTransaction(tx) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async signMessage(message) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  create(mnemonic) {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  generate() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/WarpFastsetWallet.ts
+var WarpFastsetWallet = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signTransaction(tx);
+  }
   async signTransactions(txs) {
-    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
+    if (txs.length === 0) return [];
+    const signedTxs = [];
+    for (const tx of txs) {
+      signedTxs.push(await this.signTransaction(tx));
+    }
+    return signedTxs;
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signMessage(message);
   }
   async sendTransaction(tx) {
     const { signature, ...transactionWithoutSignature } = tx;
@@ -2929,37 +2569,43 @@ var WarpFastsetWallet = class {
   async sendTransactions(txs) {
     return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
-  create(mnemonic) {
-    const seed = bip39.mnemonicToSeedSync(mnemonic);
-    const privateKey = seed.slice(0, 32);
-    const publicKey = ed25519_exports.getPublicKey(privateKey);
-    const address = FastsetClient.encodeBech32Address(publicKey);
-    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic };
+  create(mnemonic, provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.create(mnemonic);
   }
-  generate() {
-    const privateKey = ed25519_exports.utils.randomSecretKey();
-    const publicKey = ed25519_exports.getPublicKey(privateKey);
-    const address = FastsetClient.encodeBech32Address(publicKey);
-    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic: null };
+  generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.generate();
   }
   getAddress() {
-    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    return this.cachedAddress;
   }
   getPublicKey() {
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (privateKey) {
-      const privateKeyBytes = hexToUint8Array(privateKey);
-      const publicKey = ed25519_exports.getPublicKey(privateKeyBytes);
-      return uint8ArrayToHex(publicKey);
-    }
-    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
-    if (!address) return null;
-    try {
-      const addressBytes = FastsetClient.decodeBech32Address(address);
-      return uint8ArrayToHex(addressBytes);
-    } catch {
-      return null;
+    return this.cachedPublicKey;
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
     }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
   }
 };
 
@@ -2992,7 +2638,7 @@ function createFastsetAdapter(chainName, chainInfos) {
     };
   };
 }
-var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, {
+var FastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, {
   mainnet: {
     name: WarpChainName.Fastset,
     displayName: "FastSet",
@@ -3025,19 +2671,16 @@ var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, {
   }
 });
 export {
+  FastsetAdapter,
   NativeTokenSet,
   WarpFastsetExecutor,
-  WarpFastsetWallet,
-  getFastsetAdapter
+  WarpFastsetWallet
 };
 /*! Bundled license information:
 
 @scure/base/lib/esm/index.js:
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/ed25519/index.js:
-  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
-
 @noble/hashes/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */