@ardrive/turbo-sdk 1.18.0 → 1.19.0-alpha.1

package/bundles/web.bundle.min.js

@@ -303388,6 +303388,11 @@ init_dirname();
 init_buffer2();
 init_process2();
 
+// src/common/factory.ts
+init_dirname();
+init_buffer2();
+init_process2();
+
 // node_modules/@dha-team/arbundles/build/web/esm/webIndex.js
 init_dirname();
 init_buffer2();
@@ -310489,10 +310494,52 @@ var streamExportForTesting = {
 var expObj = { ...src_exports, stream: stream_exports2 };
 globalThis.arbundles ??= expObj;
 
-// src/common/factory.ts
+// src/types.ts
 init_dirname();
 init_buffer2();
 init_process2();
+var fiatCurrencyTypes = [
+  "usd",
+  "eur",
+  "gbp",
+  "cad",
+  "aud",
+  "jpy",
+  "inr",
+  "sgd",
+  "hkd",
+  "brl"
+];
+function isCurrency(currency) {
+  return fiatCurrencyTypes.includes(currency);
+}
+var tokenTypes = [
+  "arweave",
+  "solana",
+  "ethereum",
+  "kyve",
+  "matic",
+  "pol"
+];
+var isNodeUploadFolderParams = (p8) => p8.folderPath !== void 0;
+var isWebUploadFolderParams = (p8) => p8.files !== void 0;
+function isKyvePrivateKey(wallet) {
+  if (typeof wallet !== "string")
+    return false;
+  return true;
+}
+function isEthPrivateKey(wallet) {
+  if (typeof wallet !== "string")
+    return false;
+  return wallet.startsWith("0x");
+}
+var isJWK = (wallet) => wallet.kty !== void 0;
+function isSolanaWalletAdapter(walletAdapter) {
+  return "publicKey" in walletAdapter && "signMessage" in walletAdapter;
+}
+function isEthereumWalletAdapter(walletAdapter) {
+  return "getSigner" in walletAdapter;
+}
 
 // src/common/logger.ts
 init_dirname();
@@ -310504,7 +310551,7 @@ var import_winston = __toESM(require_winston(), 1);
 init_dirname();
 init_buffer2();
 init_process2();
-var version16 = "1.18.0-alpha.1";
+var version16 = "1.18.1-alpha.1";
 
 // src/common/logger.ts
 var TurboWinstonLogger = class _TurboWinstonLogger {
@@ -314929,844 +314976,213 @@ var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPayment
   }
 };
 
-// src/common/turbo.ts
+// src/common/token/index.ts
 init_dirname();
 init_buffer2();
 init_process2();
 
-// src/common/upload.ts
+// src/common/token/arweave.ts
 init_dirname();
 init_buffer2();
 init_process2();
+var import_arweave = __toESM(require_web(), 1);
 init_buffer();
 
-// node_modules/plimit-lit/dist/index.js
+// src/utils/base64.ts
 init_dirname();
 init_buffer2();
 init_process2();
-var __defProp2 = Object.defineProperty;
-var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
-var __publicField = (obj, key2, value) => {
-  __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
-  return value;
-};
-var Node = class {
-  constructor(value) {
-    __publicField(this, "value");
-    __publicField(this, "next");
-    this.value = value;
-  }
-};
-var Queue = class {
-  constructor() {
-    __publicField(this, "head");
-    __publicField(this, "tail");
-    __publicField(this, "_size", 0);
-    this.clear();
-  }
-  /**
-   * Removes all elements from the queue.
-   */
-  clear() {
-    this.head = void 0;
-    this.tail = void 0;
-    this._size = 0;
-  }
-  /**
-   * Adds a new element to the queue.
-   */
-  push(value) {
-    const node = new Node(value);
-    if (this.head && this.tail) {
-      this.tail.next = node;
-      this.tail = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-    this._size++;
-    return this._size;
-  }
-  /**
-   * Removes and returns the first element in the queue.
-   */
-  pop() {
-    if (!this.head)
-      return;
-    const current = this.head;
-    this.head = this.head.next;
-    this._size--;
-    return current.value;
-  }
-  /**
-   * Returns the number of elements in the queue.
-   */
-  get size() {
-    return this._size;
-  }
-  *[Symbol.iterator]() {
-    let current = this.head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+var import_utils28 = __toESM(require_utils5(), 1);
+init_crypto();
+init_buffer();
+function ownerToAddress(owner) {
+  return sha256B64Url(fromB64Url(owner));
+}
+function fromB64Url(input) {
+  const paddingLength = input.length % 4 === 0 ? 0 : 4 - input.length % 4;
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/").concat("=".repeat(paddingLength));
+  return Buffer.from(base64, "base64");
+}
+function toB64Url(buffer2) {
+  return (0, import_utils28.bufferTob64Url)(buffer2);
+}
+function sha256B64Url(input) {
+  return toB64Url(createHash("sha256").update(input).digest());
+}
+
+// src/utils/common.ts
+init_dirname();
+init_buffer2();
+init_process2();
+var import_amino = __toESM(require_build5(), 1);
+var import_crypto7 = __toESM(require_build4(), 1);
+var import_encoding = __toESM(require_build(), 1);
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function createTurboSigner({
+  signer: clientProvidedSigner,
+  privateKey: clientProvidedPrivateKey,
+  token = "arweave"
+}) {
+  if (clientProvidedSigner !== void 0) {
+    return clientProvidedSigner;
   }
-};
-function pLimit(concurrency) {
-  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
-    throw new TypeError("Expected `concurrency` to be a number greater than 1");
+  if (clientProvidedPrivateKey === void 0) {
+    throw new Error("A privateKey or signer must be provided.");
   }
-  const queue2 = new Queue();
-  let activeCount = 0;
-  const next = () => {
-    activeCount--;
-    if (queue2.size > 0) {
-      queue2.pop()();
-    }
-  };
-  const run2 = async (fn, resolve3, args) => {
-    activeCount++;
-    const result = (async () => fn(...args))();
-    resolve3(result);
-    try {
-      await result;
-    } catch {
-    }
-    next();
-  };
-  const enqueue = (fn, resolve3, args) => {
-    queue2.push(run2.bind(null, fn, resolve3, args));
-    (async () => {
-      await Promise.resolve();
-      if (activeCount < concurrency && queue2.size > 0) {
-        queue2.pop()();
+  switch (token) {
+    case "solana":
+      return new HexSolanaSigner2(clientProvidedPrivateKey);
+    case "ethereum":
+    case "matic":
+      if (!isEthPrivateKey(clientProvidedPrivateKey)) {
+        throw new Error(
+          "A valid Ethereum private key must be provided for EthereumSigner."
+        );
       }
-    })();
-  };
-  const generator = (fn, ...args) => new Promise((resolve3) => {
-    enqueue(fn, resolve3, args);
-  });
-  Object.defineProperties(generator, {
-    activeCount: {
-      get: () => activeCount
-    },
-    pendingCount: {
-      get: () => queue2.size
-    },
-    clearQueue: {
-      value: () => {
-        queue2.clear();
+      return new EthereumSigner(clientProvidedPrivateKey);
+    case "kyve":
+      if (!isKyvePrivateKey(clientProvidedPrivateKey)) {
+        throw new Error(
+          "A valid Kyve private key must be provided for KyveSigner."
+        );
       }
-    }
-  });
-  return generator;
+      return signerFromKyvePrivateKey(clientProvidedPrivateKey);
+    default:
+      if (!isJWK(clientProvidedPrivateKey)) {
+        throw new Error("A JWK must be provided for ArweaveSigner.");
+      }
+      return new ArweaveSigner(clientProvidedPrivateKey);
+  }
+}
+function signerFromKyvePrivateKey(privateKey) {
+  return new EthereumSigner(privateKey);
 }
 
-// src/common/upload.ts
-var developmentUploadServiceURL = "https://upload.ardrive.dev";
-var defaultUploadServiceURL = "https://upload.ardrive.io";
-var TurboUnauthenticatedUploadService = class {
+// src/common/token/arweave.ts
+var ArweaveToken = class {
   constructor({
-    url = defaultUploadServiceURL,
-    retryConfig,
+    gatewayUrl = "https://arweave.net",
+    arweave,
     logger: logger15 = TurboWinstonLogger.default,
-    token = "arweave"
-  }) {
-    this.token = token;
-    this.logger = logger15;
-    this.httpService = new TurboHTTPService({
-      url: `${url}/v1`,
-      retryConfig,
-      logger: this.logger
-    });
-  }
-  async uploadSignedDataItem({
-    dataItemStreamFactory,
-    dataItemSizeFactory,
-    signal
-  }) {
-    const fileSize = dataItemSizeFactory();
-    this.logger.debug("Uploading signed data item...");
-    return this.httpService.post({
-      endpoint: `/tx/${this.token}`,
-      signal,
-      data: dataItemStreamFactory(),
-      headers: {
-        "content-type": "application/octet-stream",
-        "content-length": `${fileSize}`
-      }
+    mintU = true,
+    pollingOptions = {
+      maxAttempts: 10,
+      pollingIntervalMs: 3e3,
+      initialBackoffMs: 7e3
+    }
+  } = {}) {
+    const url = new URL(gatewayUrl);
+    this.arweave = arweave ?? import_arweave.default.init({
+      host: url.hostname,
+      port: url.port,
+      protocol: url.protocol.replace(":", "")
     });
+    this.logger = logger15;
+    this.mintU = mintU;
+    this.pollingOptions = pollingOptions;
   }
-};
-var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUploadService {
-  constructor({
-    url = defaultUploadServiceURL,
-    retryConfig,
-    signer,
-    logger: logger15,
-    token
-  }) {
-    super({ url, retryConfig, logger: logger15, token });
-    this.signer = signer;
-  }
-  async uploadFile({
-    fileStreamFactory,
-    fileSizeFactory,
-    signal,
-    dataItemOpts
+  async createAndSubmitTx({
+    feeMultiplier,
+    target,
+    tokenAmount,
+    signer
   }) {
-    const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
-      fileStreamFactory,
-      fileSizeFactory,
-      dataItemOpts
+    const tx = await this.arweave.createTransaction({
+      target,
+      quantity: tokenAmount.toString(),
+      data: ""
     });
-    const signedDataItem = dataItemStreamFactory();
-    const fileSize = dataItemSizeFactory();
-    this.logger.debug("Uploading signed data item...");
-    return this.httpService.post({
-      endpoint: `/tx/${this.token}`,
-      signal,
-      data: signedDataItem,
-      headers: {
-        "content-type": "application/octet-stream",
-        "content-length": `${fileSize}`
-      }
+    if (feeMultiplier !== 1) {
+      tx.reward = BigNumber5(tx.reward).times(BigNumber5(feeMultiplier)).toFixed(0, BigNumber5.ROUND_UP);
+    }
+    if (this.mintU) {
+      tx.addTag("App-Name", "SmartWeaveAction");
+      tx.addTag("App-Version", "0.3.0");
+      tx.addTag("Contract", "KTzTXT_ANmF84fWEKHzWURD1LWd9QaFR9yfYUwH2Lxw");
+      tx.addTag("Input", JSON.stringify({ function: "mint" }));
+    }
+    const publicKeyB64Url = toB64Url(await signer.getPublicKey());
+    tx.setOwner(publicKeyB64Url);
+    const dataToSign = await tx.getSignatureData();
+    const signatureUint8Array = await signer.signData(dataToSign);
+    const signatureBuffer = Buffer.from(signatureUint8Array);
+    const id3 = sha256B64Url(signatureBuffer);
+    tx.setSignature({
+      id: id3,
+      owner: publicKeyB64Url,
+      signature: toB64Url(signatureBuffer)
     });
+    this.logger.debug("Submitting fund transaction...", { id: id3 });
+    await this.submitTx(tx);
+    return { id: id3, target, reward: tx.reward };
   }
-  async generateManifest({
-    paths,
-    indexFile,
-    fallbackFile
+  async pollForTxBeingAvailable({
+    txId
   }) {
-    const indexPath = (
-      // Use the user provided index file if it exists,
-      indexFile !== void 0 && paths[indexFile]?.id !== void 0 ? indexFile : (
-        // Else use index.html if it exists,
-        paths["index.html"]?.id !== void 0 ? "index.html" : (
-          // Else use the first file in the paths object.
-          Object.keys(paths)[0]
-        )
-      )
-    );
-    const fallbackId = (
-      // Use the user provided fallback file if it exists,
-      fallbackFile !== void 0 && paths[fallbackFile]?.id !== void 0 ? paths[fallbackFile].id : (
-        // Else use 404.html if it exists, else use the index path.
-        paths["404.html"]?.id ?? paths[indexPath].id
-      )
-    );
-    const manifest = {
-      manifest: "arweave/paths",
-      version: "0.2.0",
-      index: { path: indexPath },
-      paths,
-      fallback: { id: fallbackId }
-    };
-    return manifest;
-  }
-  getContentType(file, dataItemOpts) {
-    const userDefinedContentType = dataItemOpts?.tags?.find(
-      (tag) => tag.name === "Content-Type"
-    )?.value;
-    if (userDefinedContentType !== void 0) {
-      return userDefinedContentType;
-    }
-    return this.contentTypeFromFile(file);
-  }
-  async uploadFolder(params) {
-    this.logger.debug("Uploading folder...", { params });
-    const {
-      dataItemOpts,
-      signal,
-      manifestOptions = {},
-      maxConcurrentUploads = 1,
-      throwOnFailure = true
-    } = params;
-    const { disableManifest, indexFile, fallbackFile } = manifestOptions;
-    const paths = {};
-    const response = {
-      fileResponses: []
-    };
-    const errors = [];
-    const uploadFile = async (file) => {
-      const contentType = this.getContentType(file, dataItemOpts);
-      const dataItemOptsWithContentType = {
-        ...dataItemOpts,
-        tags: [
-          ...dataItemOpts?.tags?.filter(
-            (tag) => tag.name !== "Content-Type"
-          ) ?? [],
-          { name: "Content-Type", value: contentType }
-        ]
-      };
+    const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
+    this.logger.debug("Polling for transaction...", { txId });
+    await sleep(initialBackoffMs);
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      let transaction;
+      attempts++;
       try {
-        const result = await this.uploadFile({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          fileStreamFactory: () => this.getFileStreamForFile(file),
-          fileSizeFactory: () => this.getFileSize(file),
-          signal,
-          dataItemOpts: dataItemOptsWithContentType
+        const response = await this.arweave.api.post("/graphql", {
+          query: `
+          query {
+            transaction(id: "${txId}") {
+              recipient
+              owner {
+                address
+              }
+              quantity {
+                winston
+              }
+            }
+          }
+          `
         });
-        const relativePath = this.getRelativePath(file, params);
-        paths[relativePath] = { id: result.id };
-        response.fileResponses.push(result);
-      } catch (error) {
-        if (throwOnFailure) {
-          throw error;
-        }
-        this.logger.error(`Error uploading file: ${file}`, error);
-        errors.push(error);
+        transaction = response?.data?.data?.transaction;
+      } catch (err) {
+        this.logger.debug("Failed to poll for transaction...", { err });
       }
-    };
-    const files = await this.getFiles(params);
-    const limit = pLimit(maxConcurrentUploads);
-    await Promise.all(files.map((file) => limit(() => uploadFile(file))));
-    this.logger.debug("Finished uploading files", {
-      numFiles: files.length,
-      numErrors: errors.length,
-      results: response.fileResponses
-    });
-    if (errors.length > 0) {
-      response.errors = errors;
+      if (transaction) {
+        return;
+      }
+      this.logger.debug("Transaction not found...", {
+        txId,
+        attempts,
+        maxAttempts,
+        pollingIntervalMs
+      });
+      await sleep(pollingIntervalMs);
     }
-    if (disableManifest) {
-      return response;
+    throw new Error(
+      "Transaction not found after polling, transaction id: " + txId
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async submitTx(tx) {
+    try {
+      const response = await this.arweave.transactions.post(tx);
+      if (response.status !== 200) {
+        throw new Error(
+          `Failed to post transaction -- Status ${response.status}, ${response.statusText}, ${response.data}`
+        );
+      }
+      this.logger.debug("Successfully posted fund transaction...", { tx });
+    } catch (err) {
+      throw new Error(
+        `Failed to post transaction -- ${err instanceof Error ? err.message : err}`
+      );
     }
-    const manifest = await this.generateManifest({
-      paths,
-      indexFile,
-      fallbackFile
-    });
-    const tagsWithManifestContentType = [
-      ...dataItemOpts?.tags?.filter((tag) => tag.name !== "Content-Type") ?? [],
-      { name: "Content-Type", value: "application/x.arweave-manifest+json" }
-    ];
-    const manifestBuffer = Buffer.from(JSON.stringify(manifest));
-    const manifestResponse = await this.uploadFile({
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      fileStreamFactory: () => this.createManifestStream(manifestBuffer),
-      fileSizeFactory: () => manifestBuffer.byteLength,
-      signal,
-      dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType }
-    });
-    return {
-      ...response,
-      manifest,
-      manifestResponse
-    };
+    this.logger.debug("Posted transaction...", { tx });
   }
 };
-
-// src/common/turbo.ts
-var developmentTurboConfiguration = {
-  paymentServiceConfig: {
-    url: developmentPaymentServiceURL
-  },
-  uploadServiceConfig: {
-    url: developmentUploadServiceURL
-  }
-};
-var defaultTurboConfiguration = {
-  paymentServiceConfig: {
-    url: defaultPaymentServiceURL
-  },
-  uploadServiceConfig: {
-    url: defaultUploadServiceURL
-  }
-};
-var TurboUnauthenticatedClient = class {
-  constructor({
-    uploadService = new TurboUnauthenticatedUploadService({}),
-    paymentService = new TurboUnauthenticatedPaymentService({})
-  }) {
-    this.paymentService = paymentService;
-    this.uploadService = uploadService;
-  }
-  /**
-   * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
-   */
-  getFiatToAR({
-    currency
-  }) {
-    return this.paymentService.getFiatToAR({ currency });
-  }
-  /**
-   * Returns the latest conversion rates to purchase 1GiB of data for all supported currencies, including all adjustments and fees.
-   *
-   * Note: this does not take into account varying adjustments and promotions for different sizes of data. If you want to calculate the total
-   * cost in 'winc' for a given number of bytes, use getUploadCosts.
-   */
-  getFiatRates() {
-    return this.paymentService.getFiatRates();
-  }
-  /**
-   * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
-   */
-  getSupportedCountries() {
-    return this.paymentService.getSupportedCountries();
-  }
-  getBalance(address) {
-    return this.paymentService.getBalance(address);
-  }
-  /**
-   * Returns a list of all supported fiat currencies.
-   */
-  getSupportedCurrencies() {
-    return this.paymentService.getSupportedCurrencies();
-  }
-  /**
-   * Determines the price in 'winc' to upload one data item of a specific size in bytes, including all Turbo cost adjustments and fees.
-   */
-  getUploadCosts({
-    bytes: bytes4
-  }) {
-    return this.paymentService.getUploadCosts({ bytes: bytes4 });
-  }
-  /**
-   * Determines the amount of 'winc' that would be returned for a given currency and amount, including all Turbo cost adjustments and fees.
-   */
-  getWincForFiat(params) {
-    return this.paymentService.getWincForFiat(params);
-  }
-  /**
-   * Determines the amount of 'winc' that would be returned for a given token and amount, including all Turbo cost adjustments and fees.
-   */
-  getWincForToken(params) {
-    return this.paymentService.getWincForToken(params);
-  }
-  /**
-   * Uploads a signed data item to the Turbo Upload Service.
-   */
-  uploadSignedDataItem({
-    dataItemStreamFactory,
-    dataItemSizeFactory,
-    signal
-  }) {
-    return this.uploadService.uploadSignedDataItem({
-      dataItemStreamFactory,
-      dataItemSizeFactory,
-      signal
-    });
-  }
-  /**
-   * Creates a Turbo Checkout Session for a given amount and currency.
-   */
-  createCheckoutSession(params) {
-    return this.paymentService.createCheckoutSession(params);
-  }
-  /**
-   * Submits a transaction ID to the Turbo Payment Service for processing.
-   */
-  submitFundTransaction(p8) {
-    return this.paymentService.submitFundTransaction(p8);
-  }
-  /**
-   * Returns the connected target Turbo wallet addresses for all supported tokens.
-   */
-  async getTurboCryptoWallets() {
-    const wallets = await this.paymentService.getTurboCryptoWallets();
-    wallets.pol = wallets.matic;
-    return wallets;
-  }
-};
-var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
-  constructor({
-    paymentService,
-    uploadService,
-    signer
-  }) {
-    super({ paymentService, uploadService });
-    this.signer = signer;
-  }
-  /**
-   * Returns the current balance of the user's wallet in 'winc'.
-   */
-  getBalance(address) {
-    return this.paymentService.getBalance(address);
-  }
-  /**
-   * Signs and uploads raw data to the Turbo Upload Service.
-   */
-  uploadFile({
-    fileStreamFactory,
-    fileSizeFactory,
-    signal,
-    dataItemOpts
-  }) {
-    return this.uploadService.uploadFile({
-      fileStreamFactory,
-      fileSizeFactory,
-      signal,
-      dataItemOpts
-    });
-  }
-  uploadFolder(p8) {
-    return this.uploadService.uploadFolder(p8);
-  }
-  /**
-   * Submits fund transaction to the token's blockchain then sends
-   * the transaction ID to the Turbo Payment Service for processing.
-   */
-  topUpWithTokens(p8) {
-    return this.paymentService.topUpWithTokens(p8);
-  }
-};
-
-// src/common/factory.ts
-var TurboBaseFactory = class {
-  static {
-    this.logger = TurboWinstonLogger.default;
-  }
-  /* @deprecated - use TurboWinstonLogger directly */
-  static setLogLevel(level) {
-    this.logger.setLogLevel(level);
-  }
-  /* @deprecated - use TurboWinstonLogger directly */
-  static setLogFormat(format6) {
-    this.logger.setLogFormat(format6);
-  }
-  static unauthenticated({
-    paymentServiceConfig = {},
-    uploadServiceConfig = {},
-    token
-  } = {}) {
-    token = token === "pol" ? "matic" : token;
-    const paymentService = new TurboUnauthenticatedPaymentService({
-      ...paymentServiceConfig,
-      logger: this.logger,
-      token
-    });
-    const uploadService = new TurboUnauthenticatedUploadService({
-      ...uploadServiceConfig,
-      logger: this.logger,
-      token
-    });
-    return new TurboUnauthenticatedClient({
-      uploadService,
-      paymentService
-    });
-  }
-};
-
-// src/common/index.ts
-init_dirname();
-init_buffer2();
-init_process2();
-
-// src/common/currency.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var ZeroDecimalCurrency = class {
-  constructor(amt, type3) {
-    this.amt = amt;
-    this.type = type3;
-    if (amt < 0) {
-      throw new ProvidedInputError(
-        `${type3} currency amount cannot be negative`
-      );
-    }
-    this.assertDecimalPlaces(amt);
-  }
-  assertDecimalPlaces(a8) {
-    if (a8 % 1 !== 0) {
-      throw new ProvidedInputError(
-        `${this.type} currency amount must have zero decimal places`
-      );
-    }
-  }
-  get amount() {
-    return this.amt;
-  }
-};
-var TwoDecimalCurrency = class extends ZeroDecimalCurrency {
-  constructor(a8, type3) {
-    super(a8, type3);
-    this.a = a8;
-    this.type = type3;
-  }
-  assertDecimalPlaces(a8) {
-    if (a8 * 100 % 1 !== 0) {
-      throw new ProvidedInputError(
-        `${this.type} currency amount must have two decimal places`
-      );
-    }
-  }
-  get amount() {
-    return this.a * 100;
-  }
-};
-var USD = (usd) => new TwoDecimalCurrency(usd, "usd");
-var EUR = (eur) => new TwoDecimalCurrency(eur, "eur");
-var GBP = (gbp) => new TwoDecimalCurrency(gbp, "gbp");
-var CAD = (cad) => new TwoDecimalCurrency(cad, "cad");
-var AUD = (aud) => new TwoDecimalCurrency(aud, "aud");
-var INR = (inr) => new TwoDecimalCurrency(inr, "inr");
-var SGD = (sgd) => new TwoDecimalCurrency(sgd, "sgd");
-var HKD = (hkd) => new TwoDecimalCurrency(hkd, "hkd");
-var BRL = (brl) => new TwoDecimalCurrency(brl, "brl");
-var JPY = (jpy) => new ZeroDecimalCurrency(jpy, "jpy");
-var currencyMap = {
-  usd: USD,
-  eur: EUR,
-  gbp: GBP,
-  cad: CAD,
-  aud: AUD,
-  inr: INR,
-  sgd: SGD,
-  hkd: HKD,
-  brl: BRL,
-  jpy: JPY
-};
-
-// src/common/token/index.ts
-init_dirname();
-init_buffer2();
-init_process2();
-
-// src/types.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var fiatCurrencyTypes = [
-  "usd",
-  "eur",
-  "gbp",
-  "cad",
-  "aud",
-  "jpy",
-  "inr",
-  "sgd",
-  "hkd",
-  "brl"
-];
-function isCurrency(currency) {
-  return fiatCurrencyTypes.includes(currency);
-}
-var tokenTypes = [
-  "arweave",
-  "solana",
-  "ethereum",
-  "kyve",
-  "matic",
-  "pol"
-];
-var isNodeUploadFolderParams = (p8) => p8.folderPath !== void 0;
-var isWebUploadFolderParams = (p8) => p8.files !== void 0;
-function isKyvePrivateKey(wallet) {
-  if (typeof wallet !== "string")
-    return false;
-  return true;
-}
-function isEthPrivateKey(wallet) {
-  if (typeof wallet !== "string")
-    return false;
-  return wallet.startsWith("0x");
-}
-var isJWK = (wallet) => wallet.kty !== void 0;
-
-// src/common/token/arweave.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var import_arweave = __toESM(require_web(), 1);
-init_buffer();
-
-// src/utils/base64.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var import_utils28 = __toESM(require_utils5(), 1);
-init_crypto();
-init_buffer();
-function ownerToAddress(owner) {
-  return sha256B64Url(fromB64Url(owner));
-}
-function fromB64Url(input) {
-  const paddingLength = input.length % 4 === 0 ? 0 : 4 - input.length % 4;
-  const base64 = input.replace(/-/g, "+").replace(/_/g, "/").concat("=".repeat(paddingLength));
-  return Buffer.from(base64, "base64");
-}
-function toB64Url(buffer2) {
-  return (0, import_utils28.bufferTob64Url)(buffer2);
-}
-function sha256B64Url(input) {
-  return toB64Url(createHash("sha256").update(input).digest());
-}
-
-// src/utils/common.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var import_amino = __toESM(require_build5(), 1);
-var import_crypto7 = __toESM(require_build4(), 1);
-var import_encoding = __toESM(require_build(), 1);
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-function createTurboSigner({
-  signer: clientProvidedSigner,
-  privateKey: clientProvidedPrivateKey,
-  token = "arweave"
-}) {
-  if (clientProvidedSigner !== void 0) {
-    return clientProvidedSigner;
-  }
-  if (clientProvidedPrivateKey === void 0) {
-    throw new Error("A privateKey or signer must be provided.");
-  }
-  switch (token) {
-    case "solana":
-      return new HexSolanaSigner2(clientProvidedPrivateKey);
-    case "ethereum":
-    case "matic":
-      if (!isEthPrivateKey(clientProvidedPrivateKey)) {
-        throw new Error(
-          "A valid Ethereum private key must be provided for EthereumSigner."
-        );
-      }
-      return new EthereumSigner(clientProvidedPrivateKey);
-    case "kyve":
-      if (!isKyvePrivateKey(clientProvidedPrivateKey)) {
-        throw new Error(
-          "A valid Kyve private key must be provided for KyveSigner."
-        );
-      }
-      return signerFromKyvePrivateKey(clientProvidedPrivateKey);
-    default:
-      if (!isJWK(clientProvidedPrivateKey)) {
-        throw new Error("A JWK must be provided for ArweaveSigner.");
-      }
-      return new ArweaveSigner(clientProvidedPrivateKey);
-  }
-}
-function signerFromKyvePrivateKey(privateKey) {
-  return new EthereumSigner(privateKey);
-}
-
-// src/common/token/arweave.ts
-var ArweaveToken = class {
-  constructor({
-    gatewayUrl = "https://arweave.net",
-    arweave,
-    logger: logger15 = TurboWinstonLogger.default,
-    mintU = true,
-    pollingOptions = {
-      maxAttempts: 10,
-      pollingIntervalMs: 3e3,
-      initialBackoffMs: 7e3
-    }
-  } = {}) {
-    const url = new URL(gatewayUrl);
-    this.arweave = arweave ?? import_arweave.default.init({
-      host: url.hostname,
-      port: url.port,
-      protocol: url.protocol.replace(":", "")
-    });
-    this.logger = logger15;
-    this.mintU = mintU;
-    this.pollingOptions = pollingOptions;
-  }
-  async createAndSubmitTx({
-    feeMultiplier,
-    target,
-    tokenAmount,
-    signer
-  }) {
-    const tx = await this.arweave.createTransaction({
-      target,
-      quantity: tokenAmount.toString(),
-      data: ""
-    });
-    if (feeMultiplier !== 1) {
-      tx.reward = BigNumber5(tx.reward).times(BigNumber5(feeMultiplier)).toFixed(0, BigNumber5.ROUND_UP);
-    }
-    if (this.mintU) {
-      tx.addTag("App-Name", "SmartWeaveAction");
-      tx.addTag("App-Version", "0.3.0");
-      tx.addTag("Contract", "KTzTXT_ANmF84fWEKHzWURD1LWd9QaFR9yfYUwH2Lxw");
-      tx.addTag("Input", JSON.stringify({ function: "mint" }));
-    }
-    const publicKeyB64Url = toB64Url(await signer.getPublicKey());
-    tx.setOwner(publicKeyB64Url);
-    const dataToSign = await tx.getSignatureData();
-    const signatureUint8Array = await signer.signData(dataToSign);
-    const signatureBuffer = Buffer.from(signatureUint8Array);
-    const id3 = sha256B64Url(signatureBuffer);
-    tx.setSignature({
-      id: id3,
-      owner: publicKeyB64Url,
-      signature: toB64Url(signatureBuffer)
-    });
-    this.logger.debug("Submitting fund transaction...", { id: id3 });
-    await this.submitTx(tx);
-    return { id: id3, target, reward: tx.reward };
-  }
-  async pollForTxBeingAvailable({
-    txId
-  }) {
-    const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
-    this.logger.debug("Polling for transaction...", { txId });
-    await sleep(initialBackoffMs);
-    let attempts = 0;
-    while (attempts < maxAttempts) {
-      let transaction;
-      attempts++;
-      try {
-        const response = await this.arweave.api.post("/graphql", {
-          query: `
-          query {
-            transaction(id: "${txId}") {
-              recipient
-              owner {
-                address
-              }
-              quantity {
-                winston
-              }
-            }
-          }
-          `
-        });
-        transaction = response?.data?.data?.transaction;
-      } catch (err) {
-        this.logger.debug("Failed to poll for transaction...", { err });
-      }
-      if (transaction) {
-        return;
-      }
-      this.logger.debug("Transaction not found...", {
-        txId,
-        attempts,
-        maxAttempts,
-        pollingIntervalMs
-      });
-      await sleep(pollingIntervalMs);
-    }
-    throw new Error(
-      "Transaction not found after polling, transaction id: " + txId
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async submitTx(tx) {
-    try {
-      const response = await this.arweave.transactions.post(tx);
-      if (response.status !== 200) {
-        throw new Error(
-          `Failed to post transaction -- Status ${response.status}, ${response.statusText}, ${response.data}`
-        );
-      }
-      this.logger.debug("Successfully posted fund transaction...", { tx });
-    } catch (err) {
-      throw new Error(
-        `Failed to post transaction -- ${err instanceof Error ? err.message : err}`
-      );
-    }
-    this.logger.debug("Posted transaction...", { tx });
-  }
-};
-var WinstonToTokenAmount = (winston2) => winston2;
-var ARToTokenAmount = (ar) => new BigNumber5(ar).times(1e12).valueOf();
+var WinstonToTokenAmount = (winston2) => winston2;
+var ARToTokenAmount = (ar) => new BigNumber5(ar).times(1e12).valueOf();
 
 // src/common/token/ethereum.ts
 init_dirname();
@@ -349961,8 +349377,8 @@ var SolanaToken = class {
     gatewayUrl = "https://api.mainnet-beta.solana.com",
     pollingOptions = {
       maxAttempts: 10,
-      pollingIntervalMs: 5e3,
-      initialBackoffMs: 7e3
+      pollingIntervalMs: 2500,
+      initialBackoffMs: 500
     }
   } = {}) {
     this.logger = logger15;
@@ -350072,10 +349488,617 @@ function isTokenType(token) {
   return tokenTypes.includes(token);
 }
 
+// src/common/turbo.ts
+init_dirname();
+init_buffer2();
+init_process2();
+
+// src/common/upload.ts
+init_dirname();
+init_buffer2();
+init_process2();
+init_buffer();
+
+// node_modules/plimit-lit/dist/index.js
+init_dirname();
+init_buffer2();
+init_process2();
+var __defProp2 = Object.defineProperty;
+var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+var __publicField = (obj, key2, value) => {
+  __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
+  return value;
+};
+var Node = class {
+  constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
+    this.value = value;
+  }
+};
+var Queue = class {
+  constructor() {
+    __publicField(this, "head");
+    __publicField(this, "tail");
+    __publicField(this, "_size", 0);
+    this.clear();
+  }
+  /**
+   * Removes all elements from the queue.
+   */
+  clear() {
+    this.head = void 0;
+    this.tail = void 0;
+    this._size = 0;
+  }
+  /**
+   * Adds a new element to the queue.
+   */
+  push(value) {
+    const node = new Node(value);
+    if (this.head && this.tail) {
+      this.tail.next = node;
+      this.tail = node;
+    } else {
+      this.head = node;
+      this.tail = node;
+    }
+    this._size++;
+    return this._size;
+  }
+  /**
+   * Removes and returns the first element in the queue.
+   */
+  pop() {
+    if (!this.head)
+      return;
+    const current = this.head;
+    this.head = this.head.next;
+    this._size--;
+    return current.value;
+  }
+  /**
+   * Returns the number of elements in the queue.
+   */
+  get size() {
+    return this._size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number greater than 1");
+  }
+  const queue2 = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue2.size > 0) {
+      queue2.pop()();
+    }
+  };
+  const run2 = async (fn, resolve3, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve3(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve3, args) => {
+    queue2.push(run2.bind(null, fn, resolve3, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue2.size > 0) {
+        queue2.pop()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve3) => {
+    enqueue(fn, resolve3, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue2.size
+    },
+    clearQueue: {
+      value: () => {
+        queue2.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// src/common/upload.ts
+var developmentUploadServiceURL = "https://upload.ardrive.dev";
+var defaultUploadServiceURL = "https://upload.ardrive.io";
+var TurboUnauthenticatedUploadService = class {
+  constructor({
+    url = defaultUploadServiceURL,
+    retryConfig,
+    logger: logger15 = TurboWinstonLogger.default,
+    token = "arweave"
+  }) {
+    this.token = token;
+    this.logger = logger15;
+    this.httpService = new TurboHTTPService({
+      url: `${url}/v1`,
+      retryConfig,
+      logger: this.logger
+    });
+  }
+  async uploadSignedDataItem({
+    dataItemStreamFactory,
+    dataItemSizeFactory,
+    signal
+  }) {
+    const fileSize = dataItemSizeFactory();
+    this.logger.debug("Uploading signed data item...");
+    return this.httpService.post({
+      endpoint: `/tx/${this.token}`,
+      signal,
+      data: dataItemStreamFactory(),
+      headers: {
+        "content-type": "application/octet-stream",
+        "content-length": `${fileSize}`
+      }
+    });
+  }
+};
+var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUploadService {
+  constructor({
+    url = defaultUploadServiceURL,
+    retryConfig,
+    signer,
+    logger: logger15,
+    token
+  }) {
+    super({ url, retryConfig, logger: logger15, token });
+    this.signer = signer;
+  }
+  async uploadFile({
+    fileStreamFactory,
+    fileSizeFactory,
+    signal,
+    dataItemOpts
+  }) {
+    const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
+      fileStreamFactory,
+      fileSizeFactory,
+      dataItemOpts
+    });
+    const signedDataItem = dataItemStreamFactory();
+    const fileSize = dataItemSizeFactory();
+    this.logger.debug("Uploading signed data item...");
+    return this.httpService.post({
+      endpoint: `/tx/${this.token}`,
+      signal,
+      data: signedDataItem,
+      headers: {
+        "content-type": "application/octet-stream",
+        "content-length": `${fileSize}`
+      }
+    });
+  }
+  async generateManifest({
+    paths,
+    indexFile,
+    fallbackFile
+  }) {
+    const indexPath = (
+      // Use the user provided index file if it exists,
+      indexFile !== void 0 && paths[indexFile]?.id !== void 0 ? indexFile : (
+        // Else use index.html if it exists,
+        paths["index.html"]?.id !== void 0 ? "index.html" : (
+          // Else use the first file in the paths object.
+          Object.keys(paths)[0]
+        )
+      )
+    );
+    const fallbackId = (
+      // Use the user provided fallback file if it exists,
+      fallbackFile !== void 0 && paths[fallbackFile]?.id !== void 0 ? paths[fallbackFile].id : (
+        // Else use 404.html if it exists, else use the index path.
+        paths["404.html"]?.id ?? paths[indexPath].id
+      )
+    );
+    const manifest = {
+      manifest: "arweave/paths",
+      version: "0.2.0",
+      index: { path: indexPath },
+      paths,
+      fallback: { id: fallbackId }
+    };
+    return manifest;
+  }
+  getContentType(file, dataItemOpts) {
+    const userDefinedContentType = dataItemOpts?.tags?.find(
+      (tag) => tag.name === "Content-Type"
+    )?.value;
+    if (userDefinedContentType !== void 0) {
+      return userDefinedContentType;
+    }
+    return this.contentTypeFromFile(file);
+  }
+  async uploadFolder(params) {
+    this.logger.debug("Uploading folder...", { params });
+    const {
+      dataItemOpts,
+      signal,
+      manifestOptions = {},
+      maxConcurrentUploads = 1,
+      throwOnFailure = true
+    } = params;
+    const { disableManifest, indexFile, fallbackFile } = manifestOptions;
+    const paths = {};
+    const response = {
+      fileResponses: []
+    };
+    const errors = [];
+    const uploadFile = async (file) => {
+      const contentType = this.getContentType(file, dataItemOpts);
+      const dataItemOptsWithContentType = {
+        ...dataItemOpts,
+        tags: [
+          ...dataItemOpts?.tags?.filter(
+            (tag) => tag.name !== "Content-Type"
+          ) ?? [],
+          { name: "Content-Type", value: contentType }
+        ]
+      };
+      try {
+        const result = await this.uploadFile({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          fileStreamFactory: () => this.getFileStreamForFile(file),
+          fileSizeFactory: () => this.getFileSize(file),
+          signal,
+          dataItemOpts: dataItemOptsWithContentType
+        });
+        const relativePath = this.getRelativePath(file, params);
+        paths[relativePath] = { id: result.id };
+        response.fileResponses.push(result);
+      } catch (error) {
+        if (throwOnFailure) {
+          throw error;
+        }
+        this.logger.error(`Error uploading file: ${file}`, error);
+        errors.push(error);
+      }
+    };
+    const files = await this.getFiles(params);
+    const limit = pLimit(maxConcurrentUploads);
+    await Promise.all(files.map((file) => limit(() => uploadFile(file))));
+    this.logger.debug("Finished uploading files", {
+      numFiles: files.length,
+      numErrors: errors.length,
+      results: response.fileResponses
+    });
+    if (errors.length > 0) {
+      response.errors = errors;
+    }
+    if (disableManifest) {
+      return response;
+    }
+    const manifest = await this.generateManifest({
+      paths,
+      indexFile,
+      fallbackFile
+    });
+    const tagsWithManifestContentType = [
+      ...dataItemOpts?.tags?.filter((tag) => tag.name !== "Content-Type") ?? [],
+      { name: "Content-Type", value: "application/x.arweave-manifest+json" }
+    ];
+    const manifestBuffer = Buffer.from(JSON.stringify(manifest));
+    const manifestResponse = await this.uploadFile({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      fileStreamFactory: () => this.createManifestStream(manifestBuffer),
+      fileSizeFactory: () => manifestBuffer.byteLength,
+      signal,
+      dataItemOpts: { ...dataItemOpts, tags: tagsWithManifestContentType }
+    });
+    return {
+      ...response,
+      manifest,
+      manifestResponse
+    };
+  }
+};
+
+// src/common/turbo.ts
+var developmentTurboConfiguration = {
+  paymentServiceConfig: {
+    url: developmentPaymentServiceURL
+  },
+  uploadServiceConfig: {
+    url: developmentUploadServiceURL
+  }
+};
+var defaultTurboConfiguration = {
+  paymentServiceConfig: {
+    url: defaultPaymentServiceURL
+  },
+  uploadServiceConfig: {
+    url: defaultUploadServiceURL
+  }
+};
+var TurboUnauthenticatedClient = class {
+  constructor({
+    uploadService = new TurboUnauthenticatedUploadService({}),
+    paymentService = new TurboUnauthenticatedPaymentService({})
+  }) {
+    this.paymentService = paymentService;
+    this.uploadService = uploadService;
+  }
+  /**
+   * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
+   */
+  getFiatToAR({
+    currency
+  }) {
+    return this.paymentService.getFiatToAR({ currency });
+  }
+  /**
+   * Returns the latest conversion rates to purchase 1GiB of data for all supported currencies, including all adjustments and fees.
+   *
+   * Note: this does not take into account varying adjustments and promotions for different sizes of data. If you want to calculate the total
+   * cost in 'winc' for a given number of bytes, use getUploadCosts.
+   */
+  getFiatRates() {
+    return this.paymentService.getFiatRates();
+  }
+  /**
+   * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
+   */
+  getSupportedCountries() {
+    return this.paymentService.getSupportedCountries();
+  }
+  getBalance(address) {
+    return this.paymentService.getBalance(address);
+  }
+  /**
+   * Returns a list of all supported fiat currencies.
+   */
+  getSupportedCurrencies() {
+    return this.paymentService.getSupportedCurrencies();
+  }
+  /**
+   * Determines the price in 'winc' to upload one data item of a specific size in bytes, including all Turbo cost adjustments and fees.
+   */
+  getUploadCosts({
+    bytes: bytes4
+  }) {
+    return this.paymentService.getUploadCosts({ bytes: bytes4 });
+  }
+  /**
+   * Determines the amount of 'winc' that would be returned for a given currency and amount, including all Turbo cost adjustments and fees.
+   */
+  getWincForFiat(params) {
+    return this.paymentService.getWincForFiat(params);
+  }
+  /**
+   * Determines the amount of 'winc' that would be returned for a given token and amount, including all Turbo cost adjustments and fees.
+   */
+  getWincForToken(params) {
+    return this.paymentService.getWincForToken(params);
+  }
+  /**
+   * Uploads a signed data item to the Turbo Upload Service.
+   */
+  uploadSignedDataItem({
+    dataItemStreamFactory,
+    dataItemSizeFactory,
+    signal
+  }) {
+    return this.uploadService.uploadSignedDataItem({
+      dataItemStreamFactory,
+      dataItemSizeFactory,
+      signal
+    });
+  }
+  /**
+   * Creates a Turbo Checkout Session for a given amount and currency.
+   */
+  createCheckoutSession(params) {
+    return this.paymentService.createCheckoutSession(params);
+  }
+  /**
+   * Submits a transaction ID to the Turbo Payment Service for processing.
+   */
+  submitFundTransaction(p8) {
+    return this.paymentService.submitFundTransaction(p8);
+  }
+  /**
+   * Returns the connected target Turbo wallet addresses for all supported tokens.
+   */
+  async getTurboCryptoWallets() {
+    const wallets = await this.paymentService.getTurboCryptoWallets();
+    wallets.pol = wallets.matic;
+    return wallets;
+  }
+};
+var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
+  constructor({
+    paymentService,
+    uploadService,
+    signer
+  }) {
+    super({ paymentService, uploadService });
+    this.signer = signer;
+  }
+  /**
+   * Returns the current balance of the user's wallet in 'winc'.
+   */
+  getBalance(address) {
+    return this.paymentService.getBalance(address);
+  }
+  /**
+   * Signs and uploads raw data to the Turbo Upload Service.
+   */
+  uploadFile({
+    fileStreamFactory,
+    fileSizeFactory,
+    signal,
+    dataItemOpts
+  }) {
+    return this.uploadService.uploadFile({
+      fileStreamFactory,
+      fileSizeFactory,
+      signal,
+      dataItemOpts
+    });
+  }
+  uploadFolder(p8) {
+    return this.uploadService.uploadFolder(p8);
+  }
+  /**
+   * Submits fund transaction to the token's blockchain then sends
+   * the transaction ID to the Turbo Payment Service for processing.
+   */
+  topUpWithTokens(p8) {
+    return this.paymentService.topUpWithTokens(p8);
+  }
+};
+
+// src/common/factory.ts
+var TurboBaseFactory = class {
+  static {
+    this.logger = TurboWinstonLogger.default;
+  }
+  /* @deprecated - use TurboWinstonLogger directly */
+  static setLogLevel(level) {
+    this.logger.setLogLevel(level);
+  }
+  /* @deprecated - use TurboWinstonLogger directly */
+  static setLogFormat(format6) {
+    this.logger.setLogFormat(format6);
+  }
+  static unauthenticated({
+    paymentServiceConfig = {},
+    uploadServiceConfig = {},
+    token
+  } = {}) {
+    token = token === "pol" ? "matic" : token;
+    token ??= "arweave";
+    const paymentService = new TurboUnauthenticatedPaymentService({
+      ...paymentServiceConfig,
+      logger: this.logger,
+      token
+    });
+    const uploadService = new TurboUnauthenticatedUploadService({
+      ...uploadServiceConfig,
+      logger: this.logger,
+      token
+    });
+    return new TurboUnauthenticatedClient({
+      uploadService,
+      paymentService
+    });
+  }
+  getAuthenticatedTurbo({
+    privateKey,
+    signer: providedSigner,
+    paymentServiceConfig = {},
+    uploadServiceConfig = {},
+    token,
+    gatewayUrl,
+    tokenMap,
+    tokenTools,
+    logger: logger15,
+    walletAdapter
+  }) {
+    token = token === "pol" ? "matic" : token;
+    if (!token) {
+      if (providedSigner) {
+        if (providedSigner instanceof EthereumSigner) {
+          token = "ethereum";
+        } else if (providedSigner instanceof HexSolanaSigner2) {
+          token = "solana";
+        } else {
+          token = "arweave";
+        }
+      } else {
+        token = "arweave";
+      }
+    }
+    token ??= "arweave";
+    if (walletAdapter) {
+      providedSigner = this.signerFromAdapter(walletAdapter, token);
+    }
+    const turboSigner = this.getSigner({
+      providedSigner,
+      providedPrivateKey: privateKey,
+      token,
+      logger: logger15,
+      providedWalletAdapter: walletAdapter
+    });
+    if (!tokenTools) {
+      if (tokenMap && token === "arweave") {
+        tokenTools = tokenMap.arweave;
+      }
+      tokenTools = defaultTokenMap[token]?.({
+        gatewayUrl,
+        logger: logger15
+      });
+    }
+    const paymentService = new TurboAuthenticatedPaymentService({
+      ...paymentServiceConfig,
+      signer: turboSigner,
+      logger: logger15,
+      token,
+      tokenTools
+    });
+    const uploadService = this.getAuthenticatedUploadService({
+      ...uploadServiceConfig,
+      signer: turboSigner,
+      logger: logger15,
+      token
+    });
+    return new TurboAuthenticatedClient({
+      uploadService,
+      paymentService,
+      signer: turboSigner
+    });
+  }
+  signerFromAdapter(walletAdapter, token) {
+    if (token === "solana") {
+      if (!isSolanaWalletAdapter(walletAdapter)) {
+        throw new Error(
+          "Unsupported wallet adapter -- must implement publicKey and signMessage"
+        );
+      }
+      return new HexSolanaSigner(walletAdapter);
+    }
+    if (token === "ethereum") {
+      if (!isEthereumWalletAdapter(walletAdapter)) {
+        throw new Error(
+          "Unsupported wallet adapter -- must implement getSigner"
+        );
+      }
+      return new InjectedEthereumSigner(walletAdapter);
+    }
+    throw new Error(
+      "Unsupported wallet adapter -- wallet adapter is currently only supported for Solana and Ethereum"
+    );
+  }
+};
+
 // src/web/signer.ts
 init_dirname();
 init_buffer2();
 init_process2();
+init_buffer();
 
 // src/common/signer.ts
 init_dirname();
@@ -350093,11 +350116,13 @@ var TurboDataItemAbstractSigner = class {
   constructor({
     signer,
     logger: logger15 = TurboWinstonLogger.default,
-    token
+    token,
+    walletAdapter
   }) {
     this.logger = logger15;
     this.signer = signer;
     this.token = token;
+    this.walletAdapter = walletAdapter;
   }
   ownerToNativeAddress(owner, token) {
     switch (token) {
@@ -350146,6 +350171,24 @@ var TurboDataItemAbstractSigner = class {
     amount,
     gatewayUrl
   }) {
+    if (this.walletAdapter) {
+      if (!isEthereumWalletAdapter(this.walletAdapter)) {
+        throw new Error(
+          "Unsupported wallet adapter -- must implement getSigner"
+        );
+      }
+      const signer = this.walletAdapter.getSigner();
+      if (signer.sendTransaction === void 0) {
+        throw new Error(
+          "Unsupported wallet adapter -- getSigner must return a signer with sendTransaction API for crypto funds transfer"
+        );
+      }
+      const { hash: hash6 } = await signer.sendTransaction({
+        to: target,
+        value: parseEther(amount.toFixed(18))
+      });
+      return hash6;
+    }
     if (!(this.signer instanceof EthereumSigner)) {
       throw new Error(
         "Only EthereumSigner is supported for sendTransaction API currently!"
@@ -350222,7 +350265,7 @@ var TurboWebArweaveSigner = class extends TurboDataItemAbstractSigner {
     super(p8);
   }
   async setPublicKey() {
-    if (this.signer.publicKey === void 0 && this.signer instanceof InjectedArweaveSigner) {
+    if (this.signer.publicKey === void 0 && (this.signer instanceof InjectedArweaveSigner || this.signer instanceof InjectedEthereumSigner)) {
       await this.signer.setPublicKey();
     }
   }
@@ -350236,8 +350279,9 @@ var TurboWebArweaveSigner = class extends TurboDataItemAbstractSigner {
     dataItemOpts
   }) {
     await this.setPublicKey();
-    const buffer2 = await readableStreamToBuffer({
-      stream: fileStreamFactory(),
+    const fileStream = fileStreamFactory();
+    const buffer2 = fileStream instanceof Buffer ? fileStream : await readableStreamToBuffer({
+      stream: fileStream,
       size: fileSizeFactory()
     });
     this.logger.debug("Signing data item...");
@@ -350307,18 +350351,28 @@ var TurboAuthenticatedUploadService = class extends TurboAuthenticatedBaseUpload
 };
 
 // src/web/factory.ts
-var TurboFactory = class extends TurboBaseFactory {
-  static getSigner(providedSigner, providedPrivateKey, token) {
+var TurboFactory = class _TurboFactory extends TurboBaseFactory {
+  getSigner({
+    providedPrivateKey,
+    logger: logger15,
+    providedSigner,
+    providedWalletAdapter,
+    token
+  }) {
     return new TurboWebArweaveSigner({
       signer: createTurboSigner({
         signer: providedSigner,
         privateKey: providedPrivateKey,
         token
       }),
-      logger: this.logger,
-      token
+      logger: logger15,
+      token,
+      walletAdapter: providedWalletAdapter
     });
   }
+  getAuthenticatedUploadService(config2) {
+    return new TurboAuthenticatedUploadService(config2);
+  }
   static authenticated({
     privateKey,
     signer: providedSigner,
@@ -350327,53 +350381,94 @@ var TurboFactory = class extends TurboBaseFactory {
     token,
     gatewayUrl,
     tokenMap,
-    tokenTools
+    tokenTools,
+    walletAdapter
   }) {
-    token = token === "pol" ? "matic" : token;
-    if (!token) {
-      if (providedSigner) {
-        if (providedSigner instanceof EthereumSigner) {
-          token = "ethereum";
-        } else if (providedSigner instanceof HexSolanaSigner2) {
-          token = "solana";
-        } else {
-          token = "arweave";
-        }
-      } else {
-        token = "arweave";
-      }
-    }
-    const turboSigner = this.getSigner(providedSigner, privateKey, token);
-    token ??= "arweave";
-    if (!tokenTools) {
-      if (tokenMap && token === "arweave") {
-        tokenTools = tokenMap.arweave;
-      }
-      tokenTools = defaultTokenMap[token]?.({
-        gatewayUrl,
-        logger: this.logger
-      });
-    }
-    const paymentService = new TurboAuthenticatedPaymentService({
-      ...paymentServiceConfig,
-      signer: turboSigner,
-      logger: this.logger,
+    return new _TurboFactory().getAuthenticatedTurbo({
+      privateKey,
+      signer: providedSigner,
+      paymentServiceConfig,
+      uploadServiceConfig,
       token,
-      tokenTools
-    });
-    const uploadService = new TurboAuthenticatedUploadService({
-      ...uploadServiceConfig,
-      signer: turboSigner,
+      gatewayUrl,
+      tokenMap,
+      tokenTools,
       logger: this.logger,
-      token
-    });
-    return new TurboAuthenticatedClient({
-      uploadService,
-      paymentService,
-      signer: turboSigner
+      walletAdapter
     });
   }
 };
+
+// src/common/index.ts
+init_dirname();
+init_buffer2();
+init_process2();
+
+// src/common/currency.ts
+init_dirname();
+init_buffer2();
+init_process2();
+var ZeroDecimalCurrency = class {
+  constructor(amt, type3) {
+    this.amt = amt;
+    this.type = type3;
+    if (amt < 0) {
+      throw new ProvidedInputError(
+        `${type3} currency amount cannot be negative`
+      );
+    }
+    this.assertDecimalPlaces(amt);
+  }
+  assertDecimalPlaces(a8) {
+    if (a8 % 1 !== 0) {
+      throw new ProvidedInputError(
+        `${this.type} currency amount must have zero decimal places`
+      );
+    }
+  }
+  get amount() {
+    return this.amt;
+  }
+};
+var TwoDecimalCurrency = class extends ZeroDecimalCurrency {
+  constructor(a8, type3) {
+    super(a8, type3);
+    this.a = a8;
+    this.type = type3;
+  }
+  assertDecimalPlaces(a8) {
+    if (a8 * 100 % 1 !== 0) {
+      throw new ProvidedInputError(
+        `${this.type} currency amount must have two decimal places`
+      );
+    }
+  }
+  get amount() {
+    return this.a * 100;
+  }
+};
+var USD = (usd) => new TwoDecimalCurrency(usd, "usd");
+var EUR = (eur) => new TwoDecimalCurrency(eur, "eur");
+var GBP = (gbp) => new TwoDecimalCurrency(gbp, "gbp");
+var CAD = (cad) => new TwoDecimalCurrency(cad, "cad");
+var AUD = (aud) => new TwoDecimalCurrency(aud, "aud");
+var INR = (inr) => new TwoDecimalCurrency(inr, "inr");
+var SGD = (sgd) => new TwoDecimalCurrency(sgd, "sgd");
+var HKD = (hkd) => new TwoDecimalCurrency(hkd, "hkd");
+var BRL = (brl) => new TwoDecimalCurrency(brl, "brl");
+var JPY = (jpy) => new ZeroDecimalCurrency(jpy, "jpy");
+var currencyMap = {
+  usd: USD,
+  eur: EUR,
+  gbp: GBP,
+  cad: CAD,
+  aud: AUD,
+  inr: INR,
+  sgd: SGD,
+  hkd: HKD,
+  brl: BRL,
+  jpy: JPY
+};
 export {
   ARToTokenAmount,
   AUD,
@@ -350420,9 +350515,11 @@ export {
   fiatCurrencyTypes,
   isCurrency,
   isEthPrivateKey,
+  isEthereumWalletAdapter,
   isJWK,
   isKyvePrivateKey,
   isNodeUploadFolderParams,
+  isSolanaWalletAdapter,
   isTokenType,
   isWebUploadFolderParams,
   lamportToTokenAmount,