@ardrive/turbo-sdk 1.31.1 → 1.32.0-alpha.2

package/bundles/web.bundle.min.js

@@ -220860,162 +220860,6 @@ globalThis.arbundles ??= expObj;
 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",
-  "ario",
-  "solana",
-  "ethereum",
-  "kyve",
-  "matic",
-  "pol",
-  "base-eth"
-];
-var multipartPendingStatus = [
-  "ASSEMBLING",
-  "VALIDATING",
-  "FINALIZING"
-];
-var multipartFailedStatus = [
-  "UNDERFUNDED",
-  "INVALID",
-  "APPROVAL_FAILED",
-  "REVOKE_FAILED"
-];
-var multipartFinalizedStatus = ["FINALIZED"];
-var isNodeUploadFolderParams = (p9) => p9.folderPath !== void 0;
-var isWebUploadFolderParams = (p9) => p9.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;
-}
-var validChunkingModes = ["force", "disabled", "auto"];
-
-// src/common/logger.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var import_winston = __toESM(require_winston(), 1);
-
-// src/version.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var version21 = "1.31.1-alpha.2";
-
-// src/common/logger.ts
-var TurboWinstonLogger = class _TurboWinstonLogger {
-  constructor({
-    level = "info",
-    logFormat = "simple"
-  } = {}) {
-    this.silent = false;
-    if (level === "none") {
-      this.silent = true;
-    }
-    if (typeof window !== "undefined") {
-      this.logger = console;
-    } else {
-      this.logger = (0, import_winston.createLogger)({
-        level,
-        silent: this.silent,
-        defaultMeta: {
-          name: "turbo-sdk",
-          version: version21
-        },
-        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.format.json()),
-        transports: [
-          new import_winston.transports.Console({
-            format: getLogFormat(logFormat)
-          })
-        ]
-      });
-    }
-  }
-  static {
-    this.default = new _TurboWinstonLogger();
-  }
-  info(message2, ...args) {
-    if (this.silent)
-      return;
-    this.logger.info(message2, ...args);
-  }
-  warn(message2, ...args) {
-    if (this.silent)
-      return;
-    this.logger.warn(message2, ...args);
-  }
-  error(message2, ...args) {
-    if (this.silent)
-      return;
-    this.logger.error(message2, ...args);
-  }
-  debug(message2, ...args) {
-    if (this.silent)
-      return;
-    this.logger.debug(message2, ...args);
-  }
-  setLogLevel(level) {
-    this.silent = level === "none";
-    if ("silent" in this.logger) {
-      this.logger.silent = level === "none";
-    }
-    if ("level" in this.logger) {
-      this.logger.level = level;
-    }
-  }
-  setLogFormat(logFormat) {
-    if ("format" in this.logger) {
-      this.logger.format = getLogFormat(logFormat);
-    }
-  }
-};
-function getLogFormat(logFormat) {
-  return import_winston.format.combine(
-    (0, import_winston.format)((info) => {
-      if (info.stack && info.level !== "error") {
-        delete info.stack;
-      }
-      return info;
-    })(),
-    import_winston.format.errors({ stack: true }),
-    // Ensure errors show a stack trace
-    import_winston.format.timestamp(),
-    logFormat === "json" ? import_winston.format.json() : import_winston.format.simple()
-  );
-}
-
-// src/common/payment.ts
-init_dirname();
-init_buffer2();
-init_process2();
 
 // node_modules/bignumber.js/bignumber.mjs
 init_dirname();
@@ -222493,6 +222337,181 @@ function toFixedPoint(str, e12, z6) {
 }
 var BigNumber2 = clone();
 
+// src/types.ts
+var fiatCurrencyTypes = [
+  "usd",
+  "eur",
+  "gbp",
+  "cad",
+  "aud",
+  "jpy",
+  "inr",
+  "sgd",
+  "hkd",
+  "brl"
+];
+function isCurrency(currency) {
+  return fiatCurrencyTypes.includes(currency);
+}
+var tokenTypes = [
+  "arweave",
+  "ario",
+  "solana",
+  "ethereum",
+  "kyve",
+  "matic",
+  "pol",
+  "base-eth"
+];
+var ExistingBalanceFunding = class {
+};
+var OnDemandFunding = class {
+  constructor({
+    maxTokenAmount,
+    topUpBufferMultiplier = 1.1
+  }) {
+    if (maxTokenAmount !== void 0 && new BigNumber2(maxTokenAmount).isLessThan(0)) {
+      throw new Error("maxTokenAmount must be non-negative");
+    }
+    this.maxTokenAmount = maxTokenAmount !== void 0 ? new BigNumber2(maxTokenAmount) : void 0;
+    if (topUpBufferMultiplier < 1) {
+      throw new Error("topUpBufferMultiplier must be >= 1");
+    }
+    this.topUpBufferMultiplier = topUpBufferMultiplier;
+  }
+};
+var multipartPendingStatus = [
+  "ASSEMBLING",
+  "VALIDATING",
+  "FINALIZING"
+];
+var multipartFailedStatus = [
+  "UNDERFUNDED",
+  "INVALID",
+  "APPROVAL_FAILED",
+  "REVOKE_FAILED"
+];
+var multipartFinalizedStatus = ["FINALIZED"];
+var isNodeUploadFolderParams = (p9) => p9.folderPath !== void 0;
+var isWebUploadFolderParams = (p9) => p9.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;
+}
+var validChunkingModes = ["force", "disabled", "auto"];
+
+// src/common/logger.ts
+init_dirname();
+init_buffer2();
+init_process2();
+var import_winston = __toESM(require_winston(), 1);
+
+// src/version.ts
+init_dirname();
+init_buffer2();
+init_process2();
+var version21 = "1.31.1";
+
+// src/common/logger.ts
+var TurboWinstonLogger = class _TurboWinstonLogger {
+  constructor({
+    level = "info",
+    logFormat = "simple"
+  } = {}) {
+    this.silent = false;
+    if (level === "none") {
+      this.silent = true;
+    }
+    if (typeof window !== "undefined") {
+      this.logger = console;
+    } else {
+      this.logger = (0, import_winston.createLogger)({
+        level,
+        silent: this.silent,
+        defaultMeta: {
+          name: "turbo-sdk",
+          version: version21
+        },
+        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.format.json()),
+        transports: [
+          new import_winston.transports.Console({
+            format: getLogFormat(logFormat)
+          })
+        ]
+      });
+    }
+  }
+  static {
+    this.default = new _TurboWinstonLogger();
+  }
+  info(message2, ...args) {
+    if (this.silent)
+      return;
+    this.logger.info(message2, ...args);
+  }
+  warn(message2, ...args) {
+    if (this.silent)
+      return;
+    this.logger.warn(message2, ...args);
+  }
+  error(message2, ...args) {
+    if (this.silent)
+      return;
+    this.logger.error(message2, ...args);
+  }
+  debug(message2, ...args) {
+    if (this.silent)
+      return;
+    this.logger.debug(message2, ...args);
+  }
+  setLogLevel(level) {
+    this.silent = level === "none";
+    if ("silent" in this.logger) {
+      this.logger.silent = level === "none";
+    }
+    if ("level" in this.logger) {
+      this.logger.level = level;
+    }
+  }
+  setLogFormat(logFormat) {
+    if ("format" in this.logger) {
+      this.logger.format = getLogFormat(logFormat);
+    }
+  }
+};
+function getLogFormat(logFormat) {
+  return import_winston.format.combine(
+    (0, import_winston.format)((info) => {
+      if (info.stack && info.level !== "error") {
+        delete info.stack;
+      }
+      return info;
+    })(),
+    import_winston.format.errors({ stack: true }),
+    // Ensure errors show a stack trace
+    import_winston.format.timestamp(),
+    logFormat === "json" ? import_winston.format.json() : import_winston.format.simple()
+  );
+}
+
+// src/common/payment.ts
+init_dirname();
+init_buffer2();
+init_process2();
+
 // src/utils/axiosClient.ts
 init_dirname();
 init_buffer2();
@@ -262493,7 +262512,7 @@ var ARIOToken = class {
     });
     return { id: txId, target, reward: "0" };
   }
-  async pollForTxBeingAvailable() {
+  async pollTxAvailability() {
     return sleep(this.pollingOptions.initialBackoffMs);
   }
 };
@@ -262621,9 +262640,7 @@ var ArweaveToken = class {
     await this.submitTx(tx);
     return { id: id3, target, reward: tx.reward };
   }
-  async pollForTxBeingAvailable({
-    txId
-  }) {
+  async pollTxAvailability({ txId }) {
     const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
     this.logger.debug("Polling for transaction...", { txId });
     await sleep(initialBackoffMs);
@@ -262734,17 +262751,24 @@ var EthereumToken = class {
       target
     };
   }
-  async pollForTxBeingAvailable({
-    txId
-  }) {
+  async getTxAvailability(txId) {
+    const tx = await this.rpcProvider.getTransaction(txId);
+    if (tx) {
+      this.logger.debug("Transaction is available on chain", { txId, tx });
+      return true;
+    }
+    this.logger.debug("Transaction not yet available on chain", { txId });
+    return false;
+  }
+  async pollTxAvailability({ txId }) {
     await new Promise(
       (resolve3) => setTimeout(resolve3, this.pollingOptions.initialBackoffMs)
     );
     let attempts = 0;
     while (attempts < this.pollingOptions.maxAttempts) {
       try {
-        const tx = await this.rpcProvider.getTransaction(txId);
-        if (tx) {
+        const txIsAvailable = await this.getTxAvailability(txId);
+        if (txIsAvailable) {
           return;
         }
       } catch (e12) {
@@ -262755,7 +262779,7 @@ var EthereumToken = class {
       );
       attempts++;
     }
-    throw new Error("Transaction not found after polling!");
+    throw new Error(`Transaction ${txId} not found after polling!`);
   }
 };
 
@@ -262765,7 +262789,7 @@ var BaseEthToken = class extends EthereumToken {
     logger: logger19,
     gatewayUrl = defaultProdGatewayUrls["base-eth"],
     pollingOptions = {
-      initialBackoffMs: 1e3,
+      initialBackoffMs: 2500,
       maxAttempts: 10,
       pollingIntervalMs: 2500
     }
@@ -262776,6 +262800,22 @@ var BaseEthToken = class extends EthereumToken {
       pollingOptions
     });
   }
+  async getTxAvailability(txId) {
+    const tx = await this.rpcProvider.getTransactionReceipt(txId);
+    if (tx) {
+      const confirmations = await tx.confirmations();
+      if (confirmations >= 1) {
+        this.logger.debug("Transaction is available on chain", {
+          txId,
+          tx,
+          confirmations
+        });
+        return true;
+      }
+    }
+    this.logger.debug("Transaction not yet available on chain", { txId, tx });
+    return false;
+  }
 };
 
 // src/common/token/kyve.ts
@@ -262825,9 +262865,7 @@ var KyveToken = class {
     });
     return { id: txHash, target };
   }
-  async pollForTxBeingAvailable({
-    txId
-  }) {
+  async pollTxAvailability({ txId }) {
     const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
     this.logger.debug("Polling for transaction...", {
       txId,
@@ -273602,6 +273640,14 @@ var SolanaToken = class {
     tokenAmount,
     signer
   }) {
+    if (signer.signer instanceof HexSolanaSigner) {
+      const id4 = await signer.sendTransaction({
+        amount: tokenAmount,
+        target,
+        gatewayUrl: this.gatewayUrl
+      });
+      return { target, id: id4 };
+    }
     const publicKey2 = new PublicKey(
       import_bs583.default.encode(Uint8Array.from(await signer.getPublicKey()))
     );
@@ -273642,9 +273688,7 @@ var SolanaToken = class {
       "finalized"
     );
   }
-  async pollForTxBeingAvailable({
-    txId
-  }) {
+  async pollTxAvailability({ txId }) {
     const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
     this.logger.debug("Polling for transaction...", {
       txId,
@@ -274021,7 +274065,7 @@ var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPayment
     });
     const txId = fundTx.id;
     try {
-      await this.tokenTools.pollForTxBeingAvailable({ txId });
+      await this.tokenTools.pollTxAvailability({ txId });
     } catch (e12) {
       this.logger.error(
         `Failed to poll for transaction being available from ${this.token} gateway... Attempting to submit fund tx to Turbo...`,
@@ -274809,6 +274853,77 @@ function combineAbortSignals(signals) {
   return controller.signal;
 }
 
+// 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, type4) {
+    this.amt = amt;
+    this.type = type4;
+    if (amt < 0) {
+      throw new ProvidedInputError(
+        `${type4} 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, type4) {
+    super(a8, type4);
+    this.a = a8;
+    this.type = type4;
+  }
+  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/upload.ts
 function isTurboUploadFileWithStreamFactoryParams(params) {
   return "fileStreamFactory" in params;
@@ -274881,10 +274996,13 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
     retryConfig,
     signer,
     logger: logger19,
-    token
+    token,
+    paymentService
   }) {
     super({ url, retryConfig, logger: logger19, token });
+    this.enabledOnDemandTokens = ["ario", "solana", "base-eth"];
     this.signer = signer;
+    this.paymentService = paymentService;
   }
   /**
    * Signs and uploads raw data to the Turbo Upload Service.
@@ -274896,7 +275014,9 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
     events,
     chunkByteCount,
     chunkingMode,
-    maxChunkConcurrency
+    maxChunkConcurrency,
+    fundingMode,
+    maxFinalizeMs
   }) {
     if (isBlob2(data)) {
       const streamFactory = () => data.stream();
@@ -274906,7 +275026,12 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
         fileSizeFactory: sizeFactory,
         signal,
         dataItemOpts,
-        events
+        events,
+        chunkByteCount,
+        chunkingMode,
+        maxChunkConcurrency,
+        fundingMode,
+        maxFinalizeMs
       });
     }
     const dataBuffer = (() => {
@@ -274925,7 +275050,9 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
       events,
       chunkByteCount,
       chunkingMode,
-      maxChunkConcurrency
+      maxChunkConcurrency,
+      fundingMode,
+      maxFinalizeMs
     });
   }
   resolveUploadFileConfig(params) {
@@ -274950,13 +275077,21 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
     };
   }
   async uploadFile(params) {
-    const { signal, dataItemOpts, events, fileStreamFactory, fileSizeFactory } = this.resolveUploadFileConfig(params);
+    const {
+      signal,
+      dataItemOpts,
+      events,
+      fileStreamFactory,
+      fileSizeFactory,
+      fundingMode = new ExistingBalanceFunding()
+    } = this.resolveUploadFileConfig(params);
     let retries = 0;
     const maxRetries = this.retryConfig.retries ?? 3;
     const retryDelay = this.retryConfig.retryDelay ?? ((retryNumber) => retryNumber * 1e3);
     let lastError = void 0;
     let lastStatusCode = void 0;
     const emitter = new TurboEventEmitter(events);
+    let cryptoFundResult;
     while (retries < maxRetries) {
       if (signal?.aborted) {
         throw new CanceledError2();
@@ -274967,6 +275102,13 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
         dataItemOpts,
         emitter
       });
+      if (fundingMode instanceof OnDemandFunding && cryptoFundResult === void 0) {
+        const totalByteCount = dataItemSizeFactory();
+        cryptoFundResult = await this.onDemand({
+          totalByteCount,
+          onDemandFunding: fundingMode
+        });
+      }
       try {
         const { chunkByteCount, maxChunkConcurrency } = params;
         const chunkedUploader = new ChunkedUploader({
@@ -274987,7 +275129,7 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
             signal,
             events
           });
-          return response2;
+          return { ...response2, cryptoFundResult };
         }
         const response = await this.uploadSignedDataItem({
           dataItemStreamFactory,
@@ -274996,7 +275138,7 @@ var TurboAuthenticatedBaseUploadService = class extends TurboUnauthenticatedUplo
           signal,
           events
         });
-        return response;
+        return { ...response, cryptoFundResult };
       } catch (error) {
         lastError = error;
         if (error instanceof FailedRequestError) {
@@ -275089,6 +275231,7 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
       maxChunkConcurrency,
       chunkByteCount,
       chunkingMode,
+      fundingMode = new ExistingBalanceFunding(),
       maxFinalizeMs
     } = params;
     const { disableManifest, indexFile, fallbackFile } = manifestOptions;
@@ -275133,6 +275276,16 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
     };
     const files = await this.getFiles(params);
     const limit = pLimit(maxConcurrentUploads);
+    let cryptoFundResult;
+    if (fundingMode instanceof OnDemandFunding) {
+      const totalByteCount = files.reduce((acc, file) => {
+        return acc + this.getFileSize(file) + 1200;
+      }, 0);
+      cryptoFundResult = await this.onDemand({
+        totalByteCount,
+        onDemandFunding: fundingMode
+      });
+    }
     await Promise.all(files.map((file) => limit(() => uploadFile(file))));
     this.logger.debug("Finished uploading files", {
       numFiles: files.length,
@@ -275170,7 +275323,8 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
     return {
       ...response,
       manifest,
-      manifestResponse
+      manifestResponse,
+      cryptoFundResult
     };
   }
   async shareCredits({
@@ -275235,6 +275389,102 @@ ${lastError instanceof Error ? lastError.message : lastError}`;
     }
     return revokedApprovals;
   }
+  /**
+   * Triggers an upload that will top-up the wallet with Credits for the amount before uploading.
+   * First, it calculates the expected cost of the upload. Next, it checks the wallet for existing
+   * balance. If the balance is insufficient, it will attempt the top-up with the wallet in the specified `token`
+   * and await for the balance to be credited.
+   * Note: Only `ario`, `solana`, and `base-eth` tokens are currently supported for on-demand uploads.
+   */
+  async onDemand({
+    totalByteCount,
+    onDemandFunding
+  }) {
+    const { maxTokenAmount, topUpBufferMultiplier } = onDemandFunding;
+    const currentBalance = await this.paymentService.getBalance();
+    const wincPriceForOneGiB = (await this.paymentService.getUploadCosts({
+      bytes: [2 ** 30]
+    }))[0].winc;
+    const expectedWincPrice = new BigNumber2(wincPriceForOneGiB).multipliedBy(totalByteCount).dividedBy(2 ** 30).toFixed(0, BigNumber2.ROUND_UP);
+    if (BigNumber2(currentBalance.effectiveBalance).isGreaterThanOrEqualTo(
+      expectedWincPrice
+    )) {
+      this.logger.debug("Sufficient balance for on demand upload", {
+        currentBalance,
+        expectedWincPrice
+      });
+      return void 0;
+    }
+    this.logger.debug("Insufficient balance for on demand upload", {
+      currentBalance,
+      expectedWincPrice
+    });
+    if (!this.enabledOnDemandTokens.includes(this.token)) {
+      throw new Error(
+        `On-demand uploads are not supported for token: ${this.token}`
+      );
+    }
+    const topUpWincAmount = BigNumber2(expectedWincPrice).minus(currentBalance.effectiveBalance).multipliedBy(topUpBufferMultiplier).toFixed(0, BigNumber2.ROUND_UP);
+    const wincPriceForOneToken = (await this.paymentService.getWincForToken({
+      tokenAmount: tokenToBaseMap[this.token](1)
+    })).winc;
+    const topUpTokenAmount = new BigNumber2(topUpWincAmount).dividedBy(wincPriceForOneToken).multipliedBy(tokenToBaseMap[this.token](1)).toFixed(0, BigNumber2.ROUND_UP);
+    if (maxTokenAmount !== void 0) {
+      if (new BigNumber2(topUpTokenAmount).isGreaterThan(maxTokenAmount)) {
+        throw new Error(
+          `Top up token amount ${new BigNumber2(topUpTokenAmount).div(
+            exponentMap[this.token]
+          )} is greater than the maximum allowed amount of ${maxTokenAmount}`
+        );
+      }
+    }
+    this.logger.debug(
+      `Topping up wallet with ${topUpTokenAmount} ${this.token} for ${topUpWincAmount} winc`
+    );
+    const topUpResponse = await this.paymentService.topUpWithTokens({
+      tokenAmount: topUpTokenAmount
+    });
+    this.logger.debug("Top up transaction submitted", { topUpResponse });
+    const pollingOptions = {
+      pollIntervalMs: 3 * 1e3,
+      // poll every 3 seconds
+      timeoutMs: 120 * 1e3
+      // wait up to 2 minutes
+    };
+    let tries = 1;
+    const maxTries = Math.ceil(pollingOptions.timeoutMs / pollingOptions.pollIntervalMs) - 1;
+    while (topUpResponse.status !== "confirmed" && tries < maxTries) {
+      this.logger.debug("Tx not yet confirmed, waiting to poll again", {
+        tries,
+        maxTries
+      });
+      await sleep(pollingOptions.pollIntervalMs);
+      tries++;
+      try {
+        const submitFundResult = await this.paymentService.submitFundTransaction({
+          txId: topUpResponse.id
+        });
+        if (submitFundResult.status === "confirmed") {
+          this.logger.debug(
+            "Top-up transaction confirmed and balance updated",
+            { submitFundResult }
+          );
+          topUpResponse.status = "confirmed";
+          break;
+        }
+      } catch (error) {
+        this.logger.warn("Error fetching fund transaction during polling", {
+          message: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    if (tries >= maxTries) {
+      this.logger.warn(
+        "Timed out waiting for fund tx to confirm after top-up. Will continue to attempt upload but it may fail if balance is insufficient."
+      );
+    }
+    return topUpResponse;
+  }
 };
 
 // src/common/turbo.ts
@@ -275416,7 +275666,9 @@ var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
     events,
     chunkByteCount,
     chunkingMode,
-    maxChunkConcurrency
+    maxChunkConcurrency,
+    maxFinalizeMs,
+    fundingMode
   }) {
     return this.uploadService.upload({
       data,
@@ -275425,7 +275677,9 @@ var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
       events,
       chunkByteCount,
       chunkingMode,
-      maxChunkConcurrency
+      maxChunkConcurrency,
+      fundingMode,
+      maxFinalizeMs
     });
   }
   uploadFile(params) {
@@ -275565,7 +275819,8 @@ var TurboBaseFactory = class {
       ...uploadServiceConfig,
       signer: turboSigner,
       logger: logger19,
-      token
+      token,
+      paymentService
     });
     return new TurboAuthenticatedClient({
       uploadService,
@@ -275675,6 +275930,27 @@ var TurboDataItemAbstractSigner = class {
     gatewayUrl
   }) {
     if (this.walletAdapter) {
+      if (isSolanaWalletAdapter(this.walletAdapter)) {
+        const connection = new Connection(gatewayUrl, "confirmed");
+        const publicKey2 = new PublicKey(
+          this.walletAdapter.publicKey?.toString?.() || // For backwards compatibility with umi uploader
+          this.walletAdapter.publicKey?.toBuffer?.() || "<unknown>"
+        );
+        const tx2 = new Transaction2({
+          feePayer: publicKey2,
+          ...await connection.getLatestBlockhash()
+        });
+        tx2.add(
+          SystemProgram.transfer({
+            fromPubkey: publicKey2,
+            toPubkey: new PublicKey(target),
+            lamports: +new BigNumber2(amount)
+          })
+        );
+        const signedTx = await this.walletAdapter.signTransaction(tx2);
+        const id3 = await connection.sendRawTransaction(signedTx.serialize());
+        return id3;
+      }
       if (!isEthereumWalletAdapter(this.walletAdapter)) {
         throw new Error(
           "Unsupported wallet adapter -- must implement getSigner"
@@ -275978,9 +276254,10 @@ var TurboAuthenticatedUploadService = class extends TurboAuthenticatedBaseUpload
     retryConfig,
     signer,
     logger: logger19,
-    token
+    token,
+    paymentService
   }) {
-    super({ url, retryConfig, logger: logger19, token, signer });
+    super({ url, retryConfig, logger: logger19, token, signer, paymentService });
   }
   getFiles(params) {
     if (!isWebUploadFolderParams(params)) {
@@ -276066,77 +276343,6 @@ var TurboFactory = class _TurboFactory extends TurboBaseFactory {
     });
   }
 };
-
-// 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, type4) {
-    this.amt = amt;
-    this.type = type4;
-    if (amt < 0) {
-      throw new ProvidedInputError(
-        `${type4} 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, type4) {
-    super(a8, type4);
-    this.a = a8;
-    this.type = type4;
-  }
-  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 {
   ARIOToTokenAmount,
   ARIOToken,
@@ -276152,6 +276358,7 @@ export {
   EUR,
   EthereumSigner,
   EthereumToken,
+  ExistingBalanceFunding,
   GBP,
   HKD,
   HexSolanaSigner2 as HexSolanaSigner,
@@ -276159,6 +276366,7 @@ export {
   JPY,
   KYVEToTokenAmount,
   KyveToken,
+  OnDemandFunding,
   POLToTokenAmount,
   PolygonToken,
   SGD,