@ardrive/turbo-sdk 1.0.0-alpha.22 → 1.0.0-alpha.24

package/README.md

@@ -39,7 +39,7 @@ The SDK is provided in both CommonJS and ESM formats, and it's compatible with b
 ```javascript
 import { TurboFactory } from '@ardrive/turbo-sdk';
 
-const turbo = TurboFactory.unauthenticated({});
+const turbo = TurboFactory.unauthenticated();
 const rates = await turbo.getFiatRates();
 ```
 
@@ -48,7 +48,7 @@ const rates = await turbo.getFiatRates();
 ```html
 <script src="https://cdn.jsdelivr.net/npm/@ardrive/turbo-sdk"></script>
 <script>
-  const turbo = TurboFactory.unauthenticated({});
+  const turbo = TurboFactory.unauthenticated();
   const rates = await turbo.getFiatRates();
 </script>
 ```
@@ -65,7 +65,7 @@ Project's `package.json`:
 }
 ```
 
-tsconfig's `tsconfig.json`:
+Project's `tsconfig.json`:
 
 ```json
 {
@@ -82,7 +82,7 @@ Usage:
 ```javascript
 const { TurboFactory } = require('@ardrive/turbo-sdk');
 
-const turbo = TurboFactory.unauthenticated({});
+const turbo = TurboFactory.unauthenticated();
 const rates = await turbo.getFiatRates();
 ```
 
@@ -96,7 +96,7 @@ Project's `package.json`:
 }
 ```
 
-tsconfig's `tsconfig.json`:
+Project's `tsconfig.json`:
 
 ```json
 {
@@ -113,7 +113,7 @@ Usage:
 ```javascript
 import { TurboFactory } from '@ardrive/turbo-sdk/node';
 
-const turbo = TurboFactory.unauthenticated({});
+const turbo = TurboFactory.unauthenticated();
 const rates = await turbo.getFiatRates();
 ```
 
@@ -122,7 +122,7 @@ const rates = await turbo.getFiatRates();
 The SDK provides TypeScript types. When you import the SDK in a TypeScript project:
 
 ```typescript
-import Ardrive from '@ardrive/turbo-sdk/web';
+import { TurboFactory } from '@ardrive/turbo-sdk/web';
 
 // or '@ardrive/turbo-sdk/node' for Node.js projects
 ```
@@ -136,7 +136,7 @@ Types are exported from `./lib/types/index.d.ts` and should be automatically rec
 - `unauthenticated()` - Creates an instance of a client that accesses Turbo's unauthenticated services.
 
   ```typescript
-  const turbo = TurboFactory.unauthenticated({});
+  const turbo = TurboFactory.unauthenticated();
   ```
 
 - `authenticated()` - Creates an instance of a client that accesses Turbo's authenticated and unauthenticated services.
@@ -172,19 +172,23 @@ Types are exported from `./lib/types/index.d.ts` and should be automatically rec
   const rates = await turbo.getFiatRates();
   ```
 
-- `getWincForFiat({ amount, currency })` - Returns the current conversion rate for Winston Credits for the provided fiat currency and amount, including all top-up adjustments and fees.
+- `getWincForFiat({ amount })` - Returns the current amount of Winston Credits including all adjustments for the provided fiat currency, amount. To leverage promo codes, see [TurboAuthenticatedClient].
 
   ```typescript
-  const winc = await turbo.getWincForFiat({ amount: 100, currency: 'USD' });
+  const { winc, paymentAmount, quotedPaymentAmount, adjustments } =
+    await turbo.getWincForFiat({
+      amount: USD(100),
+    });
   ```
 
 - `getUploadCosts({ bytes })` - Returns the estimated cost in Winston Credits for the provided file sizes, including all upload adjustments and fees.
 
   ```typescript
-  const costs = await turbo.getUploadCosts({ bytes: [1000, 2000] });
+  const [uploadCostForFile] = await turbo.getUploadCosts({ bytes: [1024] });
+  const { winc, adjustments } = uploadCostForFile;
   ```
 
-- `uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal })` - Uploads a signed data item. The provided dataItemStreamFactory should produce a NEW signed data item stream each time is it invoked. The `dataItemSizeFactory` is a function that returns the size of the file.
+- `uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal })` - Uploads a signed data item. The provided `dataItemStreamFactory` should produce a NEW signed data item stream each time is it invoked. The `dataItemSizeFactory` is a function that returns the size of the file. The `signal` is an optional [AbortSignal] that can be used to cancel the upload or timeout the request.
 
   ```typescript
   const filePath = path.join(__dirname, './my-signed-data-item');
@@ -196,22 +200,56 @@ Types are exported from `./lib/types/index.d.ts` and should be automatically rec
   });
   ```
 
+- `createCheckoutSession({ amount, owner, promoCodes })` - Creates a Stripe checkout session for a Turbo Top Up with the provided amount, currency, owner, and optional promo codes. The returned URL can be opened in the browser, all payments are processed by Stripe.
+
+  ```typescript
+  const { url, winc, paymentAmount, quotedPaymentAmount, adjustments } =
+    await turbo.createCheckoutSession({
+      amount: USD(10.0), // $10.00 USD
+      owner: publicArweaveAddress,
+      promoCodes: ['MY_PROMO_CODE'],
+    });
+
+  // Open checkout session in a browser
+  if (process.platform === 'darwin') {
+    // macOS
+    exec(`open ${url}`);
+  } else if (process.platform === 'win32') {
+    // Windows
+    exec(`start "" "${url}"`, { shell: true });
+  } else {
+    // Linux/Unix
+    open(url);
+  }
+  ```
+
 ### TurboAuthenticatedClient
 
 - `getBalance()` - Issues a signed request to get the credit balance of a wallet measured in AR (measured in Winston Credits, or winc).
 
   ```typescript
-  const balance = await turbo.getBalance();
+  const { winc: balance } = await turbo.getBalance();
+  ```
+
+- `getWincForFiat({ amount, promoCodes })` - Returns the current amount of Winston Credits including all adjustments for the provided fiat currency, amount, and optional promo codes. Note: promo codes require an authenticated client.
+
+  ```typescript
+  const { winc, paymentAmount, quotedPaymentAmount, adjustments } =
+    await turbo.getWincForFiat({
+      amount: USD(100),
+      promoCodes: ['MY_PROMO_CODE'],
+    });
   ```
 
-- `uploadFile({ fileStreamFactory, fileSizeFactory, signal })` - Signs and uploads a raw file. The provided `fileStreamFactory` should produce a NEW file data stream each time is it invoked. The `fileSizeFactory` is a function that returns the size of the file.
+- `uploadFile({ fileStreamFactory, fileSizeFactory, signal })` - Signs and uploads a raw file. The provided `fileStreamFactory` should produce a NEW file data stream each time is it invoked. The `fileSizeFactory` is a function that returns the size of the file. The `signal` is an optional [AbortSignal] that can be used to cancel the upload or timeout the request.
 
   ```typescript
   const filePath = path.join(__dirname, './my-unsigned-file.txt');
   const fileSize = fs.stateSync(filePath).size;
-  const uploadResult = await turboAuthClient.uploadFile({
+  const uploadResult = await turbo.uploadFile({
     fileStreamFactory: () => fs.createReadStream(filePath),
     fileSizeFactory: () => fileSize,
+    // no timeout or AbortSignal provided
   });
   ```
 
@@ -223,3 +261,4 @@ If you encounter any issues or have feature requests, please file an issue on ou
 [examples]: ./examples
 [TurboUnauthenticatedClient]: #turboUnauthenticatedClient
 [TurboAuthenticatedClient]: #turboAuthenticatedClient
+[AbortSignal]: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal

package/bundles/web.bundle.min.js

@@ -47394,9 +47394,11 @@ var TurboHTTPService = class {
 };
 
 // src/common/payment.ts
+var developmentPaymentServiceURL = "https://payment.ardrive.dev";
+var defaultPaymentServiceURL = "https://payment.ardrive.io";
 var TurboUnauthenticatedPaymentService = class {
   constructor({
-    url = "https://payment.ardrive.dev",
+    url = defaultPaymentServiceURL,
     retryConfig
   }) {
     this.httpService = new TurboHTTPService({
@@ -47404,24 +47406,24 @@ var TurboUnauthenticatedPaymentService = class {
       retryConfig
     });
   }
-  async getFiatRates() {
+  getFiatRates() {
     return this.httpService.get({
       endpoint: "/rates"
     });
   }
-  async getFiatToAR({
+  getFiatToAR({
     currency
   }) {
     return this.httpService.get({
       endpoint: `/rates/${currency}`
     });
   }
-  async getSupportedCountries() {
+  getSupportedCountries() {
     return this.httpService.get({
       endpoint: "/countries"
     });
   }
-  async getSupportedCurrencies() {
+  getSupportedCurrencies() {
     return this.httpService.get({
       endpoint: "/currencies"
     });
@@ -47437,15 +47439,42 @@ var TurboUnauthenticatedPaymentService = class {
     const wincCostsForBytes = await Promise.all(fetchPricePromises);
     return wincCostsForBytes;
   }
-  async getWincForFiat({ amount, currency }) {
+  getWincForFiat({
+    amount
+  }) {
+    const { amount: paymentAmount, type: currencyType } = amount;
     return this.httpService.get({
-      endpoint: `/price/${currency}/${amount}`
+      endpoint: `/price/${currencyType}/${paymentAmount}`
+    });
+  }
+  appendPromoCodesToQuery(promoCodes) {
+    const promoCodesQuery = promoCodes.join(",");
+    return promoCodesQuery ? `?promoCode=${promoCodesQuery}` : "";
+  }
+  async getCheckout({ amount, owner, promoCodes = [] }, headers) {
+    const { amount: paymentAmount, type: currencyType } = amount;
+    const endpoint = `/top-up/checkout-session/${owner}/${currencyType}/${paymentAmount}${this.appendPromoCodesToQuery(
+      promoCodes
+    )}`;
+    const { adjustments, paymentSession, topUpQuote } = await this.httpService.get({
+      endpoint,
+      headers
     });
+    return {
+      winc: topUpQuote.winstonCreditAmount,
+      adjustments,
+      url: paymentSession.url,
+      paymentAmount: topUpQuote.paymentAmount,
+      quotedPaymentAmount: topUpQuote.quotedPaymentAmount
+    };
+  }
+  createCheckoutSession(params) {
+    return this.getCheckout(params);
   }
 };
 var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPaymentService {
   constructor({
-    url = "https://payment.ardrive.dev",
+    url = defaultPaymentServiceURL,
     retryConfig,
     signer
   }) {
@@ -47461,6 +47490,21 @@ var TurboAuthenticatedPaymentService = class extends TurboUnauthenticatedPayment
     });
     return balance.winc ? balance : { winc: "0" };
   }
+  async getWincForFiat({
+    amount,
+    promoCodes = []
+  }) {
+    return this.httpService.get({
+      endpoint: `/price/${amount.type}/${amount.amount}${this.appendPromoCodesToQuery(promoCodes)}`,
+      headers: await this.signer.generateSignedRequestHeaders()
+    });
+  }
+  async createCheckoutSession(params) {
+    return this.getCheckout(
+      params,
+      await this.signer.generateSignedRequestHeaders()
+    );
+  }
 };
 
 // src/common/turbo.ts
@@ -47468,9 +47512,11 @@ init_shim();
 
 // src/common/upload.ts
 init_shim();
+var defaultUploadServiceURL = "https://upload.ardrive.io";
+var developmentUploadServiceURL = "https://upload.ardrive.dev";
 var TurboUnauthenticatedUploadService = class {
   constructor({
-    url = "https://upload.ardrive.dev",
+    url = defaultUploadServiceURL,
     retryConfig
   }) {
     this.httpService = new TurboHTTPService({
@@ -47539,7 +47585,7 @@ var TurboUnauthenticatedClient = class {
   /**
    * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
    */
-  async getFiatToAR({
+  getFiatToAR({
     currency
   }) {
     return this.paymentService.getFiatToAR({ currency });
@@ -47550,25 +47596,25 @@ var TurboUnauthenticatedClient = class {
    * 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.
    */
-  async getFiatRates() {
+  getFiatRates() {
     return this.paymentService.getFiatRates();
   }
   /**
    * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
    */
-  async getSupportedCountries() {
+  getSupportedCountries() {
     return this.paymentService.getSupportedCountries();
   }
   /**
    * Returns a list of all supported fiat currencies.
    */
-  async getSupportedCurrencies() {
+  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.
    */
-  async getUploadCosts({
+  getUploadCosts({
     bytes
   }) {
     return this.paymentService.getUploadCosts({ bytes });
@@ -47576,16 +47622,13 @@ var TurboUnauthenticatedClient = class {
   /**
    * Determines the amount of 'winc' that would be returned for a given currency and amount, including all Turbo cost adjustments and fees.
    */
-  async getWincForFiat({
-    amount,
-    currency
-  }) {
-    return this.paymentService.getWincForFiat({ amount, currency });
+  getWincForFiat(params) {
+    return this.paymentService.getWincForFiat(params);
   }
   /**
    * Uploads a signed data item to the Turbo Upload Service.
    */
-  async uploadSignedDataItem({
+  uploadSignedDataItem({
     dataItemStreamFactory,
     dataItemSizeFactory,
     signal
@@ -47596,6 +47639,12 @@ var TurboUnauthenticatedClient = class {
       signal
     });
   }
+  /**
+   * Creates a Turbo Checkout Session for a given amount and currency.
+   */
+  createCheckoutSession(params) {
+    return this.paymentService.createCheckoutSession(params);
+  }
 };
 var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
   constructor({
@@ -47607,13 +47656,13 @@ var TurboAuthenticatedClient = class extends TurboUnauthenticatedClient {
   /**
    * Returns the current balance of the user's wallet in 'winc'.
    */
-  async getBalance() {
+  getBalance() {
     return this.paymentService.getBalance();
   }
   /**
    * Signs and uploads raw data to the Turbo Upload Service.
    */
-  async uploadFile({
+  uploadFile({
     fileStreamFactory,
     fileSizeFactory,
     signal
@@ -47648,6 +47697,34 @@ var TurboBaseFactory = class {
 // src/common/index.ts
 init_shim();
 
+// src/common/currency.ts
+init_shim();
+var ZeroDecimalCurrency = class {
+  constructor(amount, type) {
+    this.amount = amount;
+    this.type = type;
+  }
+};
+var TwoDecimalCurrency = class {
+  constructor(a, type) {
+    this.a = a;
+    this.type = type;
+  }
+  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");
+
 // src/web/signer.ts
 init_shim();
 
@@ -55651,6 +55728,15 @@ var TurboFactory = class extends TurboBaseFactory {
 // src/types.ts
 init_shim();
 export {
+  AUD,
+  BRL,
+  CAD,
+  EUR,
+  GBP,
+  HKD,
+  INR,
+  JPY,
+  SGD,
   TurboAuthenticatedClient,
   TurboAuthenticatedPaymentService,
   TurboAuthenticatedUploadService,
@@ -55658,7 +55744,14 @@ export {
   TurboUnauthenticatedClient,
   TurboUnauthenticatedPaymentService,
   TurboUnauthenticatedUploadService,
-  TurboWebArweaveSigner
+  TurboWebArweaveSigner,
+  TwoDecimalCurrency,
+  USD,
+  ZeroDecimalCurrency,
+  defaultPaymentServiceURL,
+  defaultUploadServiceURL,
+  developmentPaymentServiceURL,
+  developmentUploadServiceURL
 };
 /*! Bundled license information:
 

package/lib/cjs/common/currency.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JPY = exports.BRL = exports.HKD = exports.SGD = exports.INR = exports.AUD = exports.CAD = exports.GBP = exports.EUR = exports.USD = exports.TwoDecimalCurrency = exports.ZeroDecimalCurrency = void 0;
+class ZeroDecimalCurrency {
+    constructor(amount, type) {
+        this.amount = amount;
+        this.type = type;
+    }
+}
+exports.ZeroDecimalCurrency = ZeroDecimalCurrency;
+class TwoDecimalCurrency {
+    constructor(a, type) {
+        this.a = a;
+        this.type = type;
+    }
+    get amount() {
+        return this.a * 100;
+    }
+}
+exports.TwoDecimalCurrency = TwoDecimalCurrency;
+// Two decimal currencies that are supported by the Turbo API
+const USD = (usd) => new TwoDecimalCurrency(usd, 'usd');
+exports.USD = USD;
+const EUR = (eur) => new TwoDecimalCurrency(eur, 'eur');
+exports.EUR = EUR;
+const GBP = (gbp) => new TwoDecimalCurrency(gbp, 'gbp');
+exports.GBP = GBP;
+const CAD = (cad) => new TwoDecimalCurrency(cad, 'cad');
+exports.CAD = CAD;
+const AUD = (aud) => new TwoDecimalCurrency(aud, 'aud');
+exports.AUD = AUD;
+const INR = (inr) => new TwoDecimalCurrency(inr, 'inr');
+exports.INR = INR;
+const SGD = (sgd) => new TwoDecimalCurrency(sgd, 'sgd');
+exports.SGD = SGD;
+const HKD = (hkd) => new TwoDecimalCurrency(hkd, 'hkd');
+exports.HKD = HKD;
+const BRL = (brl) => new TwoDecimalCurrency(brl, 'brl');
+exports.BRL = BRL;
+// Zero decimal currencies that are supported by the Turbo API
+const JPY = (jpy) => new ZeroDecimalCurrency(jpy, 'jpy');
+exports.JPY = JPY;

package/lib/cjs/common/factory.js

@@ -1,9 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboBaseFactory = void 0;
+exports.TurboBaseFactory = exports.defaultTurboConfiguration = exports.developmentTurboConfiguration = void 0;
 const payment_js_1 = require("./payment.js");
 const turbo_js_1 = require("./turbo.js");
 const upload_js_1 = require("./upload.js");
+/**
+ * Testing configuration.
+ */
+exports.developmentTurboConfiguration = {
+    paymentServiceConfig: {
+        url: payment_js_1.developmentPaymentServiceURL,
+    },
+    uploadServiceConfig: {
+        url: upload_js_1.developmentUploadServiceURL,
+    },
+};
+/**
+ * Production configuration.
+ */
+exports.defaultTurboConfiguration = {
+    paymentServiceConfig: {
+        url: payment_js_1.defaultPaymentServiceURL,
+    },
+    uploadServiceConfig: {
+        url: upload_js_1.defaultUploadServiceURL,
+    },
+};
 class TurboBaseFactory {
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
         const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({

package/lib/cjs/common/index.js

@@ -33,3 +33,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./upload.js"), exports);
 __exportStar(require("./payment.js"), exports);
 __exportStar(require("./turbo.js"), exports);
+__exportStar(require("./currency.js"), exports);

package/lib/cjs/common/payment.js

@@ -1,30 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = void 0;
+exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = exports.defaultPaymentServiceURL = exports.developmentPaymentServiceURL = void 0;
 const http_js_1 = require("./http.js");
+exports.developmentPaymentServiceURL = 'https://payment.ardrive.dev';
+exports.defaultPaymentServiceURL = 'https://payment.ardrive.io';
 class TurboUnauthenticatedPaymentService {
-    constructor({ url = 'https://payment.ardrive.dev', retryConfig, }) {
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, }) {
         this.httpService = new http_js_1.TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
         });
     }
-    async getFiatRates() {
+    getFiatRates() {
         return this.httpService.get({
             endpoint: '/rates',
         });
     }
-    async getFiatToAR({ currency, }) {
+    getFiatToAR({ currency, }) {
         return this.httpService.get({
             endpoint: `/rates/${currency}`,
         });
     }
-    async getSupportedCountries() {
+    getSupportedCountries() {
         return this.httpService.get({
             endpoint: '/countries',
         });
     }
-    async getSupportedCurrencies() {
+    getSupportedCurrencies() {
         return this.httpService.get({
             endpoint: '/currencies',
         });
@@ -36,16 +38,39 @@ class TurboUnauthenticatedPaymentService {
         const wincCostsForBytes = await Promise.all(fetchPricePromises);
         return wincCostsForBytes;
     }
-    async getWincForFiat({ amount, currency }) {
+    getWincForFiat({ amount, }) {
+        const { amount: paymentAmount, type: currencyType } = amount;
         return this.httpService.get({
-            endpoint: `/price/${currency}/${amount}`,
+            endpoint: `/price/${currencyType}/${paymentAmount}`,
         });
     }
+    appendPromoCodesToQuery(promoCodes) {
+        const promoCodesQuery = promoCodes.join(',');
+        return promoCodesQuery ? `?promoCode=${promoCodesQuery}` : '';
+    }
+    async getCheckout({ amount, owner, promoCodes = [] }, headers) {
+        const { amount: paymentAmount, type: currencyType } = amount;
+        const endpoint = `/top-up/checkout-session/${owner}/${currencyType}/${paymentAmount}${this.appendPromoCodesToQuery(promoCodes)}`;
+        const { adjustments, paymentSession, topUpQuote } = await this.httpService.get({
+            endpoint,
+            headers,
+        });
+        return {
+            winc: topUpQuote.winstonCreditAmount,
+            adjustments,
+            url: paymentSession.url,
+            paymentAmount: topUpQuote.paymentAmount,
+            quotedPaymentAmount: topUpQuote.quotedPaymentAmount,
+        };
+    }
+    createCheckoutSession(params) {
+        return this.getCheckout(params);
+    }
 }
 exports.TurboUnauthenticatedPaymentService = TurboUnauthenticatedPaymentService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
-    constructor({ url = 'https://payment.ardrive.dev', retryConfig, signer, }) {
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, signer, }) {
         super({ url, retryConfig });
         this.signer = signer;
     }
@@ -59,5 +84,14 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
         // 404's don't return a balance, so default to 0
         return balance.winc ? balance : { winc: '0' };
     }
+    async getWincForFiat({ amount, promoCodes = [], }) {
+        return this.httpService.get({
+            endpoint: `/price/${amount.type}/${amount.amount}${this.appendPromoCodesToQuery(promoCodes)}`,
+            headers: await this.signer.generateSignedRequestHeaders(),
+        });
+    }
+    async createCheckoutSession(params) {
+        return this.getCheckout(params, await this.signer.generateSignedRequestHeaders());
+    }
 }
 exports.TurboAuthenticatedPaymentService = TurboAuthenticatedPaymentService;