@ardrive/turbo-sdk 1.20.2 → 1.21.0

package/bundles/web.bundle.min.js

@@ -310551,7 +310551,7 @@ var import_winston = __toESM(require_winston(), 1);
 init_dirname();
 init_buffer2();
 init_process2();
-var version16 = "1.20.2-alpha.1";
+var version16 = "1.20.2";
 
 // src/common/logger.ts
 var TurboWinstonLogger = class _TurboWinstonLogger {
@@ -314732,277 +314732,6 @@ var TurboHTTPService = class {
   }
 };
 
-// src/common/payment.ts
-var developmentPaymentServiceURL = "https://payment.ardrive.dev";
-var defaultPaymentServiceURL = "https://payment.ardrive.io";
-var TurboUnauthenticatedPaymentService = class {
-  constructor({
-    url = defaultPaymentServiceURL,
-    retryConfig,
-    logger: logger15 = TurboWinstonLogger.default,
-    token = "arweave"
-  }) {
-    this.logger = logger15;
-    this.httpService = new TurboHTTPService({
-      url: `${url}/v1`,
-      retryConfig,
-      logger: this.logger
-    });
-    this.token = token;
-  }
-  async getBalance(address) {
-    const balance = await this.httpService.get({
-      endpoint: `/account/balance/${this.token}?address=${address}`,
-      allowedStatuses: [200, 404]
-    });
-    return balance.winc ? balance : {
-      winc: "0",
-      controlledWinc: "0",
-      effectiveBalance: "0",
-      givenApprovals: [],
-      receivedApprovals: []
-    };
-  }
-  getFiatRates() {
-    return this.httpService.get({
-      endpoint: "/rates"
-    });
-  }
-  getFiatToAR({
-    currency
-  }) {
-    return this.httpService.get({
-      endpoint: `/rates/${currency}`
-    });
-  }
-  getSupportedCountries() {
-    return this.httpService.get({
-      endpoint: "/countries"
-    });
-  }
-  getSupportedCurrencies() {
-    return this.httpService.get({
-      endpoint: "/currencies"
-    });
-  }
-  async getUploadCosts({
-    bytes: bytes4
-  }) {
-    const fetchPricePromises = bytes4.map(
-      (byteCount) => this.httpService.get({
-        endpoint: `/price/bytes/${byteCount}`
-      })
-    );
-    const wincCostsForBytes = await Promise.all(fetchPricePromises);
-    return wincCostsForBytes;
-  }
-  getWincForFiat({
-    amount,
-    promoCodes = [],
-    nativeAddress = "placeholder"
-    // For price checks we only check promo code eligibility, a placeholder can be used
-  }) {
-    return this.httpService.get({
-      endpoint: `/price/${amount.type}/${amount.amount}?destinationAddress=${nativeAddress}&${this.appendPromoCodesToQuery(
-        promoCodes
-      )}`
-    });
-  }
-  async getWincForToken({
-    tokenAmount
-  }) {
-    const { actualPaymentAmount, fees, winc } = await this.httpService.get({
-      endpoint: `/price/${this.token}/${tokenAmount}`
-    });
-    return {
-      winc,
-      fees,
-      actualTokenAmount: tokenAmount.toString(),
-      equivalentWincTokenAmount: actualPaymentAmount.toString()
-    };
-  }
-  appendPromoCodesToQuery(promoCodes) {
-    const promoCodesQuery = promoCodes.join(",");
-    return promoCodesQuery ? `promoCode=${promoCodesQuery}` : "";
-  }
-  async getTurboCryptoWallets() {
-    const { addresses } = await this.httpService.get({
-      endpoint: "/info"
-    });
-    return addresses;
-  }
-  async getCheckout({
-    amount,
-    owner,
-    promoCodes = [],
-    uiMode = "hosted"
-  }, headers) {
-    const { amount: paymentAmount, type: currencyType } = amount;
-    const endpoint = `/top-up/checkout-session/${owner}/${currencyType}/${paymentAmount}?uiMode=${uiMode}${promoCodes.length > 0 ? `&${this.appendPromoCodesToQuery(promoCodes)}` : ""}&token=${this.token}`;
-    const { adjustments, paymentSession, topUpQuote, fees } = await this.httpService.get({
-      endpoint,
-      headers
-    });
-    return {
-      winc: topUpQuote.winstonCreditAmount,
-      adjustments,
-      fees,
-      url: paymentSession.url ?? void 0,
-      id: paymentSession.id,
-      client_secret: paymentSession.client_secret ?? void 0,
-      /** @deprecated -- backfilled for backwards compatibility, use actualPaymentAmount */
-      paymentAmount: topUpQuote.paymentAmount,
-      actualPaymentAmount: topUpQuote.paymentAmount,
-      quotedPaymentAmount: topUpQuote.quotedPaymentAmount
-    };
-  }
-  createCheckoutSession(params) {
-    return this.getCheckout(params);
-  }
-  async submitFundTransaction({
-    txId
-  }) {
-    const response = await this.httpService.post({
-      endpoint: `/account/balance/${this.token}`,
-      data: Buffer.from(JSON.stringify({ tx_id: txId }))
-    });
-    if ("creditedTransaction" in response) {
-      return {
-        id: response.creditedTransaction.transactionId,
-        quantity: response.creditedTransaction.transactionQuantity,
-        owner: response.creditedTransaction.destinationAddress,
-        winc: response.creditedTransaction.winstonCreditAmount,
-        token: response.creditedTransaction.tokenType,
-        status: "confirmed",
-        block: response.creditedTransaction.blockHeight
-      };
-    } else if ("pendingTransaction" in response) {
-      return {
-        id: response.pendingTransaction.transactionId,
-        quantity: response.pendingTransaction.transactionQuantity,
-        owner: response.pendingTransaction.destinationAddress,
-        winc: response.pendingTransaction.winstonCreditAmount,
-        token: response.pendingTransaction.tokenType,
-        status: "pending"
-      };
-    } else if ("failedTransaction" in response) {
-      return {
-        id: response.failedTransaction.transactionId,
-        quantity: response.failedTransaction.transactionQuantity,
-        owner: response.failedTransaction.destinationAddress,
-        winc: response.failedTransaction.winstonCreditAmount,
-        token: response.failedTransaction.tokenType,
-        status: "failed"
-      };
-    }
-    throw new Error("Unknown response from payment service: " + response);
-  }
-  async getCreditShareApprovals({
-    userAddress
-  }) {
-    const response = await this.httpService.get({
-      endpoint: `/account/approvals/get?userAddress=${userAddress}`,
-      allowedStatuses: [200, 404]
-    });
-    if (response?.givenApprovals === void 0 && response?.receivedApprovals === void 0) {
-      return {
-        givenApprovals: [],
-        receivedApprovals: []
-      };
-    }
-    return response;
-  }
-};
-var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPaymentService {
-  constructor({
-    url = defaultPaymentServiceURL,
-    retryConfig,
-    signer,
-    logger: logger15 = TurboWinstonLogger.default,
-    token = "arweave",
-    tokenTools
-  }) {
-    super({ url, retryConfig, logger: logger15, token });
-    this.signer = signer;
-    this.tokenTools = tokenTools;
-  }
-  async getBalance(userAddress) {
-    userAddress ??= await this.signer.getNativeAddress();
-    return super.getBalance(userAddress);
-  }
-  async getCreditShareApprovals({
-    userAddress
-  }) {
-    userAddress ??= await this.signer.getNativeAddress();
-    return super.getCreditShareApprovals({ userAddress });
-  }
-  async getWincForFiat({
-    amount,
-    promoCodes = []
-  }) {
-    return super.getWincForFiat({
-      amount,
-      promoCodes,
-      nativeAddress: await this.signer.getNativeAddress()
-    });
-  }
-  async createCheckoutSession(params) {
-    return this.getCheckout(params);
-  }
-  async getTargetWalletForFund() {
-    const { addresses } = await this.httpService.get({
-      endpoint: "/info"
-    });
-    const walletAddress = addresses[this.token];
-    if (!walletAddress) {
-      throw new Error(`No wallet address found for token type: ${this.token}`);
-    }
-    return walletAddress;
-  }
-  async topUpWithTokens({
-    feeMultiplier = 1,
-    tokenAmount: tokenAmountV
-  }) {
-    if (!this.tokenTools) {
-      throw new Error(`Token type not supported for crypto fund ${this.token}`);
-    }
-    const tokenAmount = new BigNumber5(tokenAmountV);
-    const target = await this.getTargetWalletForFund();
-    this.logger.debug("Funding account...", {
-      feeMultiplier,
-      tokenAmount,
-      target
-    });
-    const fundTx = await this.tokenTools.createAndSubmitTx({
-      target,
-      tokenAmount,
-      feeMultiplier,
-      signer: this.signer
-    });
-    const txId = fundTx.id;
-    try {
-      await this.tokenTools.pollForTxBeingAvailable({ txId });
-    } catch (e12) {
-      this.logger.error(
-        `Failed to poll for transaction being available from ${this.token} gateway... Attempting to submit fund tx to Turbo...`,
-        e12
-      );
-    }
-    try {
-      return {
-        ...await this.submitFundTransaction({ txId }),
-        target: fundTx.target,
-        reward: fundTx.reward
-      };
-    } catch (e12) {
-      this.logger.debug("Failed to submit fund transaction...", e12);
-      throw Error(
-        `Failed to submit fund transaction! Save this Transaction ID and try again with 'turbo.submitFundTransaction(id)': ${txId}`
-      );
-    }
-  }
-};
-
 // src/common/token/index.ts
 init_dirname();
 init_buffer2();
@@ -315031,10 +314760,10 @@ function fromB64Url(input) {
   return Buffer.from(base64, "base64");
 }
 function toB64Url(buffer2) {
-  return (0, import_utils28.bufferTob64Url)(buffer2);
+  return (0, import_utils28.bufferTob64Url)(Uint8Array.from(buffer2));
 }
 function sha256B64Url(input) {
-  return toB64Url(createHash("sha256").update(input).digest());
+  return toB64Url(createHash("sha256").update(Uint8Array.from(input)).digest());
 }
 
 // src/utils/common.ts
@@ -315062,6 +314791,7 @@ function createTurboSigner({
     case "solana":
       return new HexSolanaSigner2(clientProvidedPrivateKey);
     case "ethereum":
+    case "pol":
     case "matic":
       if (!isEthPrivateKey(clientProvidedPrivateKey)) {
         throw new Error(
@@ -349510,6 +349240,14 @@ var defaultTokenMap = {
   matic: (config2) => new PolygonToken(config2),
   pol: (config2) => new PolygonToken(config2)
 };
+var exponentMap = {
+  arweave: 12,
+  solana: 9,
+  ethereum: 18,
+  kyve: 6,
+  matic: 18,
+  pol: 18
+};
 var tokenToBaseMap = {
   arweave: (a8) => ARToTokenAmount(a8),
   solana: (a8) => SOLToTokenAmount(a8),
@@ -349522,6 +349260,292 @@ function isTokenType(token) {
   return tokenTypes.includes(token);
 }
 
+// src/common/payment.ts
+var developmentPaymentServiceURL = "https://payment.ardrive.dev";
+var defaultPaymentServiceURL = "https://payment.ardrive.io";
+var TurboUnauthenticatedPaymentService = class {
+  constructor({
+    url = defaultPaymentServiceURL,
+    retryConfig,
+    logger: logger15 = TurboWinstonLogger.default,
+    token = "arweave"
+  }) {
+    this.logger = logger15;
+    this.httpService = new TurboHTTPService({
+      url: `${url}/v1`,
+      retryConfig,
+      logger: this.logger
+    });
+    this.token = token;
+  }
+  async getBalance(address) {
+    const balance = await this.httpService.get({
+      endpoint: `/account/balance/${this.token}?address=${address}`,
+      allowedStatuses: [200, 404]
+    });
+    return balance.winc ? balance : {
+      winc: "0",
+      controlledWinc: "0",
+      effectiveBalance: "0",
+      givenApprovals: [],
+      receivedApprovals: []
+    };
+  }
+  getFiatRates() {
+    return this.httpService.get({
+      endpoint: "/rates"
+    });
+  }
+  getFiatToAR({
+    currency
+  }) {
+    return this.httpService.get({
+      endpoint: `/rates/${currency}`
+    });
+  }
+  getSupportedCountries() {
+    return this.httpService.get({
+      endpoint: "/countries"
+    });
+  }
+  getSupportedCurrencies() {
+    return this.httpService.get({
+      endpoint: "/currencies"
+    });
+  }
+  async getUploadCosts({
+    bytes: bytes4
+  }) {
+    const fetchPricePromises = bytes4.map(
+      (byteCount) => this.httpService.get({
+        endpoint: `/price/bytes/${byteCount}`
+      })
+    );
+    const wincCostsForBytes = await Promise.all(fetchPricePromises);
+    return wincCostsForBytes;
+  }
+  getWincForFiat({
+    amount,
+    promoCodes = [],
+    nativeAddress = "placeholder"
+    // For price checks we only check promo code eligibility, a placeholder can be used
+  }) {
+    return this.httpService.get({
+      endpoint: `/price/${amount.type}/${amount.amount}?destinationAddress=${nativeAddress}&${this.appendPromoCodesToQuery(
+        promoCodes
+      )}`
+    });
+  }
+  async getWincForToken({
+    tokenAmount
+  }) {
+    const { actualPaymentAmount, fees, winc } = await this.httpService.get({
+      endpoint: `/price/${this.token}/${tokenAmount}`
+    });
+    return {
+      winc,
+      fees,
+      actualTokenAmount: tokenAmount.toString(),
+      equivalentWincTokenAmount: actualPaymentAmount.toString()
+    };
+  }
+  appendPromoCodesToQuery(promoCodes) {
+    const promoCodesQuery = promoCodes.join(",");
+    return promoCodesQuery ? `promoCode=${promoCodesQuery}` : "";
+  }
+  async getTurboCryptoWallets() {
+    const { addresses } = await this.httpService.get({
+      endpoint: "/info"
+    });
+    return addresses;
+  }
+  async getCheckout({
+    amount,
+    owner,
+    promoCodes = [],
+    uiMode = "hosted"
+  }, headers) {
+    const { amount: paymentAmount, type: currencyType } = amount;
+    const endpoint = `/top-up/checkout-session/${owner}/${currencyType}/${paymentAmount}?uiMode=${uiMode}${promoCodes.length > 0 ? `&${this.appendPromoCodesToQuery(promoCodes)}` : ""}&token=${this.token}`;
+    const { adjustments, paymentSession, topUpQuote, fees } = await this.httpService.get({
+      endpoint,
+      headers
+    });
+    return {
+      winc: topUpQuote.winstonCreditAmount,
+      adjustments,
+      fees,
+      url: paymentSession.url ?? void 0,
+      id: paymentSession.id,
+      client_secret: paymentSession.client_secret ?? void 0,
+      /** @deprecated -- backfilled for backwards compatibility, use actualPaymentAmount */
+      paymentAmount: topUpQuote.paymentAmount,
+      actualPaymentAmount: topUpQuote.paymentAmount,
+      quotedPaymentAmount: topUpQuote.quotedPaymentAmount
+    };
+  }
+  createCheckoutSession(params) {
+    return this.getCheckout(params);
+  }
+  async submitFundTransaction({
+    txId
+  }) {
+    const response = await this.httpService.post({
+      endpoint: `/account/balance/${this.token}`,
+      data: Buffer.from(JSON.stringify({ tx_id: txId }))
+    });
+    if ("creditedTransaction" in response) {
+      return {
+        id: response.creditedTransaction.transactionId,
+        quantity: response.creditedTransaction.transactionQuantity,
+        owner: response.creditedTransaction.destinationAddress,
+        winc: response.creditedTransaction.winstonCreditAmount,
+        token: response.creditedTransaction.tokenType,
+        status: "confirmed",
+        block: response.creditedTransaction.blockHeight
+      };
+    } else if ("pendingTransaction" in response) {
+      return {
+        id: response.pendingTransaction.transactionId,
+        quantity: response.pendingTransaction.transactionQuantity,
+        owner: response.pendingTransaction.destinationAddress,
+        winc: response.pendingTransaction.winstonCreditAmount,
+        token: response.pendingTransaction.tokenType,
+        status: "pending"
+      };
+    } else if ("failedTransaction" in response) {
+      return {
+        id: response.failedTransaction.transactionId,
+        quantity: response.failedTransaction.transactionQuantity,
+        owner: response.failedTransaction.destinationAddress,
+        winc: response.failedTransaction.winstonCreditAmount,
+        token: response.failedTransaction.tokenType,
+        status: "failed"
+      };
+    }
+    throw new Error("Unknown response from payment service: " + response);
+  }
+  async getCreditShareApprovals({
+    userAddress
+  }) {
+    const response = await this.httpService.get({
+      endpoint: `/account/approvals/get?userAddress=${userAddress}`,
+      allowedStatuses: [200, 404]
+    });
+    if (response?.givenApprovals === void 0 && response?.receivedApprovals === void 0) {
+      return {
+        givenApprovals: [],
+        receivedApprovals: []
+      };
+    }
+    return response;
+  }
+  async getTokenPriceForBytes({
+    byteCount
+  }) {
+    const wincPriceForOneToken = (await this.getWincForToken({
+      tokenAmount: tokenToBaseMap[this.token](1)
+    })).winc;
+    const wincPriceForOneGiB = (await this.getUploadCosts({
+      bytes: [2 ** 30]
+    }))[0].winc;
+    const tokenPriceForOneGiB = new BigNumber5(wincPriceForOneGiB).dividedBy(
+      wincPriceForOneToken
+    );
+    const tokenPriceForBytes = tokenPriceForOneGiB.dividedBy(2 ** 30).times(byteCount).toFixed(exponentMap[this.token]);
+    return { byteCount, tokenPrice: tokenPriceForBytes, token: this.token };
+  }
+};
+var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPaymentService {
+  constructor({
+    url = defaultPaymentServiceURL,
+    retryConfig,
+    signer,
+    logger: logger15 = TurboWinstonLogger.default,
+    token = "arweave",
+    tokenTools
+  }) {
+    super({ url, retryConfig, logger: logger15, token });
+    this.signer = signer;
+    this.tokenTools = tokenTools;
+  }
+  async getBalance(userAddress) {
+    userAddress ??= await this.signer.getNativeAddress();
+    return super.getBalance(userAddress);
+  }
+  async getCreditShareApprovals({
+    userAddress
+  }) {
+    userAddress ??= await this.signer.getNativeAddress();
+    return super.getCreditShareApprovals({ userAddress });
+  }
+  async getWincForFiat({
+    amount,
+    promoCodes = []
+  }) {
+    return super.getWincForFiat({
+      amount,
+      promoCodes,
+      nativeAddress: await this.signer.getNativeAddress()
+    });
+  }
+  async createCheckoutSession(params) {
+    return this.getCheckout(params);
+  }
+  async getTargetWalletForFund() {
+    const { addresses } = await this.httpService.get({
+      endpoint: "/info"
+    });
+    const walletAddress = addresses[this.token];
+    if (!walletAddress) {
+      throw new Error(`No wallet address found for token type: ${this.token}`);
+    }
+    return walletAddress;
+  }
+  async topUpWithTokens({
+    feeMultiplier = 1,
+    tokenAmount: tokenAmountV
+  }) {
+    if (!this.tokenTools) {
+      throw new Error(`Token type not supported for crypto fund ${this.token}`);
+    }
+    const tokenAmount = new BigNumber5(tokenAmountV);
+    const target = await this.getTargetWalletForFund();
+    this.logger.debug("Funding account...", {
+      feeMultiplier,
+      tokenAmount,
+      target
+    });
+    const fundTx = await this.tokenTools.createAndSubmitTx({
+      target,
+      tokenAmount,
+      feeMultiplier,
+      signer: this.signer
+    });
+    const txId = fundTx.id;
+    try {
+      await this.tokenTools.pollForTxBeingAvailable({ txId });
+    } catch (e12) {
+      this.logger.error(
+        `Failed to poll for transaction being available from ${this.token} gateway... Attempting to submit fund tx to Turbo...`,
+        e12
+      );
+    }
+    try {
+      return {
+        ...await this.submitFundTransaction({ txId }),
+        target: fundTx.target,
+        reward: fundTx.reward
+      };
+    } catch (e12) {
+      this.logger.debug("Failed to submit fund transaction...", e12);
+      throw Error(
+        `Failed to submit fund transaction! Save this Transaction ID and try again with 'turbo.submitFundTransaction(id)': ${txId}`
+      );
+    }
+  }
+};
+
 // src/common/turbo.ts
 init_dirname();
 init_buffer2();
@@ -350001,6 +350025,14 @@ var TurboUnauthenticatedClient = class {
   getWincForToken(params) {
     return this.paymentService.getWincForToken(params);
   }
+  /**
+   * Determines the price in the instantiated token to upload one data item of a specific size in bytes, including all Turbo cost adjustments and fees.
+   */
+  getTokenPriceForBytes({
+    byteCount
+  }) {
+    return this.paymentService.getTokenPriceForBytes({ byteCount });
+  }
   /**
    * Uploads a signed data item to the Turbo Upload Service.
    */
@@ -350264,7 +350296,7 @@ var TurboDataItemAbstractSigner = class {
   ownerToNativeAddress(owner, token) {
     switch (token) {
       case "solana":
-        return import_bs584.default.encode(fromB64Url(owner));
+        return import_bs584.default.encode(Uint8Array.from(fromB64Url(owner)));
       case "ethereum":
       case "matic":
       case "pol":
@@ -350273,7 +350305,9 @@ var TurboDataItemAbstractSigner = class {
         return (0, import_amino3.pubkeyToAddress)(
           {
             type: "tendermint/PubKeySecp256k1",
-            value: (0, import_encoding3.toBase64)(import_crypto32.Secp256k1.compressPubkey(fromB64Url(owner)))
+            value: (0, import_encoding3.toBase64)(
+              import_crypto32.Secp256k1.compressPubkey(Uint8Array.from(fromB64Url(owner)))
+            )
           },
           "kyve"
         );
@@ -350285,7 +350319,7 @@ var TurboDataItemAbstractSigner = class {
   async generateSignedRequestHeaders() {
     const nonce = randomBytes(16).toString("hex");
     const buffer2 = Buffer.from(nonce);
-    const signature2 = await this.signer.sign(buffer2);
+    const signature2 = await this.signer.sign(Uint8Array.from(buffer2));
     const publicKey2 = toB64Url(this.signer.publicKey);
     return {
       "x-public-key": publicKey2,
@@ -350650,6 +350684,7 @@ export {
   developmentPaymentServiceURL,
   developmentTurboConfiguration,
   developmentUploadServiceURL,
+  exponentMap,
   fiatCurrencyTypes,
   isCurrency,
   isEthPrivateKey,

package/lib/cjs/cli/cli.js

@@ -24,6 +24,7 @@ const index_js_1 = require("./commands/index.js");
 const listShares_js_1 = require("./commands/listShares.js");
 const revokeCredits_js_1 = require("./commands/revokeCredits.js");
 const shareCredits_js_1 = require("./commands/shareCredits.js");
+const tokenPrice_js_1 = require("./commands/tokenPrice.js");
 const options_js_1 = require("./options.js");
 const utils_js_1 = require("./utils.js");
 (0, utils_js_1.applyOptions)(commander_1.program
@@ -51,6 +52,11 @@ const utils_js_1 = require("./utils.js");
     .description('Get the current Credits estimate for byte, crypto, or fiat value'), [options_js_1.optionMap.value, options_js_1.optionMap.type]).action(async (_commandOptions, command) => {
     await (0, utils_js_1.runCommand)(command, index_js_1.price);
 });
+(0, utils_js_1.applyOptions)(commander_1.program
+    .command('token-price')
+    .description('Get the current token price for provided byte value'), [options_js_1.optionMap.byteCount]).action(async (_commandOptions, command) => {
+    await (0, utils_js_1.runCommand)(command, tokenPrice_js_1.tokenPrice);
+});
 (0, utils_js_1.applyOptions)(commander_1.program
     .command('share-credits')
     .description('Create a Turbo credit share approval'), options_js_1.shareCreditsOptions).action(async (_commandOptions, command) => {

package/lib/cjs/cli/commands/shareCredits.js

@@ -33,7 +33,7 @@ async function shareCredits(options) {
     const result = await turbo.shareCredits({
         approvedAddress,
         approvedWincAmount,
-        expiresBySeconds,
+        expiresBySeconds: expiresBySeconds !== undefined ? +expiresBySeconds : undefined,
     });
     console.log(JSON.stringify({ message: 'Created credit share approval!', ...result }, null, 2));
 }