@zucchinifi/dapp-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,727 @@
+// src/utils.ts
+function toZats(amount) {
+  if (typeof amount === "number") {
+    amount = amount.toString();
+  }
+  amount = amount.replace(/,/g, "");
+  const parts = amount.split(".");
+  let whole = parts[0];
+  let fraction = parts[1] || "";
+  if (fraction.length > 8) {
+    throw new Error("Amount has more than 8 decimal places");
+  }
+  while (fraction.length < 8) {
+    fraction += "0";
+  }
+  const total = whole + fraction;
+  return BigInt(total);
+}
+function fromZats(amount) {
+  const zats = BigInt(amount).toString();
+  const padded = zats.padStart(9, "0");
+  const whole = padded.slice(0, -8);
+  const fraction = padded.slice(-8);
+  const cleanFraction = fraction.replace(/0+$/, "");
+  if (cleanFraction === "") {
+    return whole;
+  }
+  return `${whole}.${cleanFraction}`;
+}
+function shortenAddress(address, chars = 4) {
+  if (!address) return "";
+  if (address.length <= chars * 2 + 3) return address;
+  return `${address.slice(0, chars + 3)}...${address.slice(-chars)}`;
+}
+
+// src/zip321.ts
+import { bech32 as bech322, bech32m as bech32m2 } from "bech32";
+import bs58check2 from "bs58check";
+
+// src/unified_address.ts
+import { bech32m, bech32 } from "bech32";
+import bs58check from "bs58check";
+
+// src/f4jumble.ts
+import { blake2bInit, blake2bUpdate, blake2bFinal } from "blakejs";
+function get_h_pers(i) {
+  const p = new Uint8Array(16);
+  p.set([85, 65, 95, 70, 52, 74, 117, 109, 98, 108, 101, 95, 72, i, 0, 0]);
+  return p;
+}
+function get_g_pers(i, j) {
+  const p = new Uint8Array(16);
+  p.set([85, 65, 95, 70, 52, 74, 117, 109, 98, 108, 101, 95, 71, i, j & 255, j >> 8 & 255]);
+  return p;
+}
+function xor(target, source) {
+  const len = Math.min(target.length, source.length);
+  for (let i = 0; i < len; i++) {
+    target[i] ^= source[i];
+  }
+}
+var State = class {
+  constructor(message) {
+    const leftLen = Math.min(64, Math.floor(message.length / 2));
+    this.left = message.subarray(0, leftLen);
+    this.right = message.subarray(leftLen);
+  }
+  h_round(i) {
+    const ctx = blake2bInit(this.left.length, null, null, get_h_pers(i));
+    blake2bUpdate(ctx, this.right);
+    const hash = blake2bFinal(ctx);
+    xor(this.left, hash);
+  }
+  g_round(i) {
+    const outBytes = 64;
+    const numChunks = Math.ceil(this.right.length / outBytes);
+    for (let j = 0; j < numChunks; j++) {
+      const ctx = blake2bInit(outBytes, null, null, get_g_pers(i, j));
+      blake2bUpdate(ctx, this.left);
+      const hash = blake2bFinal(ctx);
+      const offset = j * outBytes;
+      const targetChunk = this.right.subarray(offset, offset + outBytes);
+      xor(targetChunk, hash);
+    }
+  }
+  apply_f4jumble() {
+    this.g_round(0);
+    this.h_round(0);
+    this.g_round(1);
+    this.h_round(1);
+  }
+  apply_f4jumble_inv() {
+    this.h_round(1);
+    this.g_round(1);
+    this.h_round(0);
+    this.g_round(0);
+  }
+};
+function f4jumble(message) {
+  const msgCopy = new Uint8Array(message);
+  const state = new State(msgCopy);
+  state.apply_f4jumble();
+  return msgCopy;
+}
+function f4jumble_inv(message) {
+  const msgCopy = new Uint8Array(message);
+  const state = new State(msgCopy);
+  state.apply_f4jumble_inv();
+  return msgCopy;
+}
+
+// src/unified_address.ts
+var TYPE_P2PKH = 0;
+var TYPE_P2SH = 1;
+var TYPE_SAPLING = 2;
+var TYPE_ORCHARD = 3;
+function parseUnifiedAddress(unifiedAddress) {
+  if (!unifiedAddress.startsWith("u")) {
+    throw new Error("Not a Unified Address (must start with 'u')");
+  }
+  const { prefix: hrp, words: decodedWords } = bech32m.decode(unifiedAddress, 1e3);
+  if (hrp !== "u" && hrp !== "utest") {
+    throw new Error(`Invalid prefix: ${hrp} `);
+  }
+  const unjumbled = f4jumble_inv(new Uint8Array(bech32m.fromWords(decodedWords)));
+  if (!unjumbled) throw new Error("F4Jumble failed");
+  const padding = new Uint8Array(16);
+  const hrpBytes = new TextEncoder().encode(hrp);
+  padding.set(hrpBytes);
+  const suffix = unjumbled.slice(-16);
+  let isValidPadding = true;
+  for (let i = 0; i < 16; i++) {
+    if (suffix[i] !== padding[i]) {
+      isValidPadding = false;
+      break;
+    }
+  }
+  if (!isValidPadding) {
+    throw new Error("Invalid padding");
+  }
+  const data = unjumbled.slice(0, -16);
+  const receivers = [];
+  let offset = 0;
+  let lastTypeCode = -1;
+  while (offset < data.length) {
+    const { value: typeCode, bytes: typeCodeLength } = readCompactSize(data, offset);
+    offset += typeCodeLength;
+    const { value: length, bytes: lengthLength } = readCompactSize(data, offset);
+    offset += lengthLength;
+    if (offset + length > data.length) {
+      throw new Error("Invalid receiver length");
+    }
+    const receiverData = data.slice(offset, offset + length);
+    offset += length;
+    if (typeCode < lastTypeCode) {
+      throw new Error("Receivers not sorted by type code");
+    }
+    lastTypeCode = typeCode;
+    switch (typeCode) {
+      case TYPE_P2PKH:
+        if (length !== 20) throw new Error("Invalid P2PKH length");
+        const p2pkhPrefix = hrp === "u" ? [28, 184] : [29, 37];
+        receivers.push({ type: "p2pkh", typeCode, data: receiverData, address: bs58check.encode(Buffer.concat([Buffer.from(p2pkhPrefix), Buffer.from(receiverData)])) });
+        break;
+      case TYPE_P2SH:
+        if (length !== 20) throw new Error("Invalid P2SH length");
+        const p2shPrefix = hrp === "u" ? [28, 189] : [28, 186];
+        receivers.push({ type: "p2sh", typeCode, data: receiverData, address: bs58check.encode(Buffer.concat([Buffer.from(p2shPrefix), Buffer.from(receiverData)])) });
+        break;
+      case TYPE_SAPLING:
+        if (length !== 43) throw new Error("Invalid Sapling length");
+        const saplingHrp = hrp === "u" ? "zs" : "ztestsapling";
+        receivers.push({ type: "sapling", typeCode, data: receiverData, address: bech32.encode(saplingHrp, bech32.toWords(receiverData), 1e3) });
+        break;
+      case TYPE_ORCHARD:
+        if (length !== 43) throw new Error("Invalid Orchard length");
+        const tlv = new Uint8Array(1 + 1 + receiverData.length);
+        tlv[0] = 3;
+        tlv[1] = receiverData.length;
+        tlv.set(receiverData, 2);
+        const payloadWithPadding = new Uint8Array(tlv.length + 16);
+        payloadWithPadding.set(tlv);
+        payloadWithPadding.set(padding, tlv.length);
+        const jumbledOrchard = f4jumble(payloadWithPadding);
+        const orchardWords = bech32m.toWords(jumbledOrchard);
+        const orchardAddr = bech32m.encode(hrp, orchardWords, 1e3);
+        receivers.push({ type: "orchard", typeCode, data: receiverData, address: orchardAddr });
+        break;
+      default:
+        receivers.push({ type: "unknown", typeCode, data: receiverData, address: "" });
+    }
+  }
+  const result = {
+    unknown: []
+  };
+  for (const receiver of receivers) {
+    switch (receiver.type) {
+      case "p2pkh":
+      case "p2sh":
+        result.transparent = receiver.address;
+        break;
+      case "sapling":
+        result.sapling = receiver.address;
+        break;
+      case "orchard":
+        result.orchard = receiver.address;
+        break;
+      case "unknown":
+        result.unknown?.push({ typeCode: receiver.typeCode, data: receiver.data });
+        break;
+    }
+  }
+  return result;
+}
+function readCompactSize(data, offset) {
+  const first = data[offset];
+  if (first < 253) {
+    return { value: first, bytes: 1 };
+  } else if (first === 253) {
+    const val = data[offset + 1] | data[offset + 2] << 8;
+    return { value: val, bytes: 3 };
+  } else if (first === 254) {
+    const val = data[offset + 1] | data[offset + 2] << 8 | data[offset + 3] << 16 | data[offset + 4] << 24;
+    return { value: val, bytes: 5 };
+  } else {
+    throw new Error("CompactSize 8 bytes not supported");
+  }
+}
+
+// src/zip321.ts
+var Zip321ParsingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Zip321ParsingError";
+  }
+};
+var Zip321Parser = class {
+  /**
+   * Parses a zcash: URI into a list of Payment objects.
+   * @param uri The zcash URI string.
+   * @param options Parsing options.
+   * @returns An array of Payment objects.
+   * @throws Zip321ParsingError if the URI is invalid.
+   */
+  static parse(uri, options = {}) {
+    if (!uri.startsWith("zcash:")) {
+      throw new Zip321ParsingError("Invalid scheme: must start with zcash:");
+    }
+    const parts = uri.substring(6).split("?");
+    const path = parts[0];
+    const query = parts[1];
+    if (parts.length > 2) {
+      throw new Zip321ParsingError("Invalid URI: multiple question marks");
+    }
+    const params = new URLSearchParams(query || "");
+    const payments = /* @__PURE__ */ new Map();
+    const getPayment = (index) => {
+      if (!payments.has(index)) {
+        payments.set(index, { address: "" });
+      }
+      return payments.get(index);
+    };
+    if (path && path.length > 0) {
+      if (!this.isValidAddress(path)) {
+        throw new Zip321ParsingError(`Invalid address in path: ${path}`);
+      }
+      const p = getPayment(0);
+      p.address = path;
+    }
+    params.forEach((value, key) => {
+      const match = key.match(/^([a-zA-Z][a-zA-Z0-9+-]*)(\.(\d+))?$/);
+      if (!match) {
+        if (key.startsWith("req-")) {
+          throw new Zip321ParsingError(`Unknown required parameter: ${key}`);
+        }
+        return;
+      }
+      const paramName = match[1];
+      const indexStr = match[3];
+      let index = 0;
+      if (indexStr) {
+        if (indexStr.startsWith("0")) {
+          throw new Zip321ParsingError(`Invalid index (leading zero): ${indexStr}`);
+        }
+        index = parseInt(indexStr, 10);
+        if (index > 9999) {
+          throw new Zip321ParsingError(`Index out of range: ${indexStr}`);
+        }
+      } else {
+        index = 0;
+      }
+      if (index === 0 && paramName === "address" && path.length > 0) {
+        throw new Zip321ParsingError("Duplicate address: defined in path and query");
+      }
+      const payment = getPayment(index);
+      switch (paramName) {
+        case "address":
+          if (payment.address) throw new Zip321ParsingError(`Duplicate address for index ${index}`);
+          if (!this.isValidAddress(value)) throw new Zip321ParsingError(`Invalid address: ${value}`);
+          payment.address = value;
+          break;
+        case "amount":
+          if (payment.amount !== void 0) throw new Zip321ParsingError(`Duplicate amount for index ${index}`);
+          if (payment.assetId) throw new Zip321ParsingError(`Amount and req-asset cannot both be present for index ${index}`);
+          payment.amount = this.parseAmount(value);
+          break;
+        case "req-asset":
+          if (payment.assetId) throw new Zip321ParsingError(`Duplicate req-asset for index ${index}`);
+          if (payment.amount !== void 0) throw new Zip321ParsingError(`Amount and req-asset cannot both be present for index ${index}`);
+          const assetData = this.parseAsset(value);
+          payment.assetId = assetData.assetId;
+          payment.amount = assetData.amount;
+          break;
+        case "memo":
+          if (payment.memo) throw new Zip321ParsingError(`Duplicate memo for index ${index}`);
+          if (!this.isValidBase64Url(value)) throw new Zip321ParsingError(`Invalid Base64URL memo: ${value}`);
+          payment.memo = value;
+          break;
+        case "label":
+          if (payment.label) throw new Zip321ParsingError(`Duplicate label for index ${index}`);
+          payment.label = value;
+          break;
+        case "message":
+          if (payment.message) throw new Zip321ParsingError(`Duplicate message for index ${index}`);
+          payment.message = value;
+          break;
+        default:
+          if (paramName.startsWith("req-")) {
+            throw new Zip321ParsingError(`Unknown required parameter: ${paramName}`);
+          }
+          if (!payment.otherParams) payment.otherParams = {};
+          payment.otherParams[paramName] = value;
+          break;
+      }
+    });
+    const result = [];
+    const sortedIndices = Array.from(payments.keys()).sort((a, b) => a - b);
+    for (const idx of sortedIndices) {
+      const p = payments.get(idx);
+      if (!p.address) {
+        throw new Zip321ParsingError(`Missing address for index ${idx}`);
+      }
+      if (this.isTransparent(p.address) && p.memo) {
+        throw new Zip321ParsingError(`Memo not allowed for transparent address at index ${idx}`);
+      }
+      if ((this.isTransparent(p.address) || this.isSapling(p.address)) && p.assetId) {
+        throw new Zip321ParsingError(`Custom assets not allowed for transparent/Sapling address at index ${idx}`);
+      }
+      result.push(p);
+    }
+    if (result.length === 0) {
+      throw new Zip321ParsingError("No payments found in URI");
+    }
+    if (options.useOrchard) {
+      for (const p of result) {
+        if (this.isUnified(p.address)) {
+          try {
+            const ua = parseUnifiedAddress(p.address);
+            if (ua.orchard) {
+              p.address = ua.orchard;
+            }
+          } catch (e) {
+            console.warn("Failed to extract Orchard receiver from UA:", e);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  static isValidAddress(address) {
+    return this.isTransparent(address) || this.isSapling(address) || this.isUnified(address);
+  }
+  static isTransparent(address) {
+    try {
+      bs58check2.decode(address);
+      return address.startsWith("t");
+    } catch {
+      return false;
+    }
+  }
+  static isSapling(address) {
+    try {
+      const decoded = bech322.decode(address);
+      return decoded.prefix === "zs" || decoded.prefix === "ztestsapling";
+    } catch {
+      return false;
+    }
+  }
+  static isUnified(address) {
+    try {
+      const decoded = bech32m2.decode(address, 1e3);
+      return decoded.prefix === "u" || decoded.prefix === "utest";
+    } catch (e) {
+      return false;
+    }
+  }
+  static parseAmount(value) {
+    if (!/^\d+(\.\d{1,8})?$/.test(value)) {
+      throw new Zip321ParsingError(`Invalid amount format: ${value}`);
+    }
+    const parts = value.split(".");
+    let whole = BigInt(parts[0]);
+    let fraction = parts[1] || "";
+    fraction = fraction.padEnd(8, "0");
+    const zatoshis = whole * 100000000n + BigInt(fraction);
+    if (zatoshis > 2100000000000000n) {
+      throw new Zip321ParsingError(`Amount exceeds max supply: ${value}`);
+    }
+    return zatoshis;
+  }
+  static parseAsset(base64) {
+    if (!this.isValidBase64Url(base64)) {
+      throw new Zip321ParsingError(`Invalid Base64URL asset: ${base64}`);
+    }
+    const b64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4;
+    const padded = pad ? b64 + "=".repeat(4 - pad) : b64;
+    let buffer;
+    try {
+      const binString = atob(padded);
+      buffer = new Uint8Array(binString.length);
+      for (let i = 0; i < binString.length; i++) {
+        buffer[i] = binString.charCodeAt(i);
+      }
+    } catch (e) {
+      throw new Zip321ParsingError(`Failed to decode asset base64: ${e}`);
+    }
+    if (buffer[0] !== 0) {
+      throw new Zip321ParsingError(`Unsupported asset version: ${buffer[0]}`);
+    }
+    const amountBytes = buffer.slice(1, 9);
+    let amount = 0n;
+    for (let i = 0; i < 8; i++) {
+      amount += BigInt(amountBytes[i]) << BigInt(i * 8);
+    }
+    const assetIdBytes = buffer.slice(9);
+    const assetId = Array.from(assetIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { assetId, amount };
+  }
+  static isValidBase64Url(str) {
+    return /^[A-Za-z0-9\-_]*$/.test(str);
+  }
+};
+var Zip321Generator = class {
+  /**
+   * Creates a ZIP 321 compliant URI from a list of payments.
+   * @param payments List of Payment objects.
+   * @param options Generation options.
+   * @returns The formatted zcash: URI.
+   * @throws Error if payments list is empty or invalid.
+   */
+  static create(payments, options = {}) {
+    if (!payments || payments.length === 0) {
+      throw new Error("Payments list cannot be empty");
+    }
+    const processedPayments = payments.map((p) => {
+      if (options.useOrchard && Zip321Parser["isUnified"](p.address)) {
+        try {
+          const ua = parseUnifiedAddress(p.address);
+          if (ua.orchard) {
+            return { ...p, address: ua.orchard };
+          }
+        } catch (e) {
+          console.warn("Failed to extract Orchard receiver from UA:", e);
+        }
+      }
+      return p;
+    });
+    processedPayments.forEach((p, i) => {
+      if (!p.address) throw new Error(`Payment at index ${i} missing address`);
+    });
+    const parts = [];
+    const primary = processedPayments[0];
+    let uri = `zcash:${primary.address}`;
+    const addParam = (key, value, index) => {
+      if (value === void 0) return;
+      const paramKey = index !== void 0 && index > 0 ? `${key}.${index}` : key;
+      parts.push(`${paramKey}=${value}`);
+    };
+    if (primary.assetId) {
+      addParam("req-asset", this.formatAsset(primary.assetId, primary.amount || 0n));
+    } else if (primary.amount !== void 0) {
+      addParam("amount", this.formatAmount(primary.amount));
+    }
+    addParam("memo", primary.memo);
+    addParam("label", primary.label);
+    addParam("message", primary.message);
+    if (primary.otherParams) {
+      Object.entries(primary.otherParams).forEach(([k, v]) => addParam(k, v));
+    }
+    for (let i = 1; i < processedPayments.length; i++) {
+      const p = processedPayments[i];
+      addParam("address", p.address, i);
+      if (p.assetId) {
+        addParam("req-asset", this.formatAsset(p.assetId, p.amount || 0n), i);
+      } else if (p.amount !== void 0) {
+        addParam("amount", this.formatAmount(p.amount), i);
+      }
+      addParam("memo", p.memo, i);
+      addParam("label", p.label, i);
+      addParam("message", p.message, i);
+      if (p.otherParams) {
+        Object.entries(p.otherParams).forEach(([k, v]) => addParam(k, v, i));
+      }
+    }
+    if (parts.length > 0) {
+      uri += `?${parts.join("&")}`;
+    }
+    return uri;
+  }
+  static formatAmount(zatoshis) {
+    const whole = zatoshis / 100000000n;
+    const frac = zatoshis % 100000000n;
+    if (frac === 0n) {
+      return whole.toString();
+    }
+    let fracStr = frac.toString().padStart(8, "0");
+    fracStr = fracStr.replace(/0+$/, "");
+    return `${whole}.${fracStr}`;
+  }
+  static formatAsset(assetId, amount) {
+    const buffer = new Uint8Array(1 + 8 + 32);
+    buffer[0] = 0;
+    for (let i = 0; i < 8; i++) {
+      buffer[1 + i] = Number(amount >> BigInt(i * 8) & 0xffn);
+    }
+    for (let i = 0; i < 32; i++) {
+      buffer[9 + i] = parseInt(assetId.substr(i * 2, 2), 16);
+    }
+    let binary = "";
+    for (let i = 0; i < buffer.length; i++) {
+      binary += String.fromCharCode(buffer[i]);
+    }
+    const b64 = btoa(binary);
+    return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+};
+function parsePaymentUri(uri, options = {}) {
+  return Zip321Parser.parse(uri, options);
+}
+function createPaymentUri(payments, options = {}) {
+  return Zip321Generator.create(payments, options);
+}
+
+// src/qrcode.ts
+import QRCode from "qrcode";
+var DEFAULT_LOGO = "data:image/png;base64,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";
+async function generateQRCode(text, options = {}) {
+  const {
+    width = 300,
+    margin = 2,
+    color = { dark: "#000000", light: "#ffffff" },
+    logoUrl = DEFAULT_LOGO,
+    logoWidth = 60,
+    logoHeight = 60
+  } = options;
+  try {
+    const qrDataUrl = await QRCode.toDataURL(text, {
+      width,
+      margin,
+      color,
+      errorCorrectionLevel: "H"
+      // High error correction for logo overlay
+    });
+    if (!logoUrl) {
+      return qrDataUrl;
+    }
+    if (typeof document === "undefined") {
+      console.warn("Logo overlay requires browser environment (Canvas API). Returning plain QR code.");
+      return qrDataUrl;
+    }
+    return new Promise((resolve, reject) => {
+      const canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = width;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas context"));
+        return;
+      }
+      const qrImage = new Image();
+      qrImage.onload = () => {
+        ctx.drawImage(qrImage, 0, 0);
+        const logo = new Image();
+        logo.crossOrigin = "Anonymous";
+        logo.onload = () => {
+          const x = (width - logoWidth) / 2;
+          const y = (width - logoHeight) / 2;
+          ctx.drawImage(logo, x, y, logoWidth, logoHeight);
+          resolve(canvas.toDataURL("image/png"));
+        };
+        logo.onerror = (err) => {
+          console.warn("Failed to load logo image", err);
+          resolve(qrDataUrl);
+        };
+        logo.src = logoUrl;
+      };
+      qrImage.onerror = (err) => reject(err);
+      qrImage.src = qrDataUrl;
+    });
+  } catch (error) {
+    throw new Error(`Failed to generate QR code: ${error}`);
+  }
+}
+
+// src/index.ts
+var ZucchiniSDK = class {
+  /**
+   * Check if the Zucchini extension is installed and the provider is injected.
+   */
+  get isInstalled() {
+    return typeof window !== "undefined" && !!window.zucchini;
+  }
+  /**
+   * Get the provider instance.
+   * @throws Error if Zucchini is not installed.
+   */
+  get provider() {
+    if (!this.isInstalled) {
+      throw new Error("Zucchini Wallet is not installed");
+    }
+    return window.zucchini;
+  }
+  /**
+   * Connect to the wallet.
+   * Requests permission from the user to access their accounts.
+   * @param permissions List of permissions to request.
+   */
+  async connect(permissions = []) {
+    return this.request({ method: "connect", params: { permissions } });
+  }
+  /**
+   * Send a transaction.
+   * Requires 'send_transaction' permission.
+   */
+  async sendTransaction(args) {
+    return this.request({
+      method: "sendTransaction",
+      params: args
+    });
+  }
+  async getBalance() {
+    return this.request({
+      method: "getBalance"
+    });
+  }
+  async getAddresses() {
+    return this.request({
+      method: "getAddresses"
+    });
+  }
+  async getNetwork() {
+    return this.request({
+      method: "getNetwork"
+    });
+  }
+  /**
+   * Send a generic request to the wallet.
+   */
+  async request(args) {
+    return this.provider.request(args);
+  }
+  on(event, handler) {
+    this.provider.on(event, handler);
+  }
+  off(event, handler) {
+    this.provider.off(event, handler);
+  }
+  async disconnect() {
+    return this.request({ method: "disconnect" });
+  }
+  async isConnected() {
+    try {
+      return await this.request({ method: "isConnected" });
+    } catch (e) {
+      return false;
+    }
+  }
+  async getUniversalViewingKey() {
+    return this.request({ method: "getUniversalViewingKey" });
+  }
+  async getAllViewingKeys() {
+    return this.request({ method: "getAllViewingKeys" });
+  }
+  async getWalletStatus() {
+    return this.request({ method: "getWalletStatus" });
+  }
+  async getTokens() {
+    const API_BASE_URL = "https://api.zucchinifi.xyz";
+    const res = await fetch(`${API_BASE_URL}/tokens`);
+    if (!res.ok) throw new Error("Failed to fetch tokens");
+    return res.json();
+  }
+  async getSwapQuote(args) {
+    const API_BASE_URL = "https://api.zucchinifi.xyz";
+    const { from, to, amount, recipient, refundAddress } = args;
+    const params = new URLSearchParams({
+      from,
+      to,
+      amount,
+      recipient: recipient || "0x0000000000000000000000000000000000000000",
+      refundAddress: refundAddress || "0x0000000000000000000000000000000000000000",
+      dry: "true"
+    });
+    const res = await fetch(`${API_BASE_URL}/swap/quote?${params.toString()}`);
+    const data = await res.json();
+    if (data.error) {
+      throw new Error(data.error);
+    }
+    return data.quote;
+  }
+};
+var zucchini = new ZucchiniSDK();
+export {
+  Zip321Generator,
+  Zip321Parser,
+  Zip321ParsingError,
+  ZucchiniSDK,
+  createPaymentUri,
+  fromZats,
+  generateQRCode,
+  parsePaymentUri,
+  parseUnifiedAddress,
+  shortenAddress,
+  toZats,
+  zucchini
+};