@ardrive/turbo-sdk 1.0.0-beta.1 → 1.0.0-beta.2

package/lib/cjs/common/turbo.js

@@ -11,7 +11,7 @@ class TurboUnauthenticatedClient {
     /**
      * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
      */
-    async getFiatToAR({ currency, }) {
+    getFiatToAR({ currency, }) {
         return this.paymentService.getFiatToAR({ currency });
     }
     /**
@@ -20,42 +20,49 @@ class TurboUnauthenticatedClient {
      * 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({ bytes, }) {
+    getUploadCosts({ bytes, }) {
         return this.paymentService.getUploadCosts({ bytes });
     }
     /**
      * 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({ dataItemStreamFactory, signal, }) {
+    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);
+    }
 }
 exports.TurboUnauthenticatedClient = TurboUnauthenticatedClient;
 class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
@@ -65,14 +72,18 @@ class TurboAuthenticatedClient 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({ fileStreamFactory, signal, }) {
-        return this.uploadService.uploadFile({ fileStreamFactory, signal });
+    uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        return this.uploadService.uploadFile({
+            fileStreamFactory,
+            fileSizeFactory,
+            signal,
+        });
     }
 }
 exports.TurboAuthenticatedClient = TurboAuthenticatedClient;

package/lib/cjs/common/upload.js

@@ -9,7 +9,8 @@ class TurboUnauthenticatedUploadService {
             retryConfig,
         });
     }
-    async uploadSignedDataItem({ dataItemStreamFactory, signal, }) {
+    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
+        const fileSize = dataItemSizeFactory();
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -17,6 +18,7 @@ class TurboUnauthenticatedUploadService {
             data: dataItemStreamFactory(),
             headers: {
                 'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
             },
         });
     }
@@ -28,10 +30,13 @@ class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService
         super({ url, retryConfig });
         this.signer = signer;
     }
-    async uploadFile({ fileStreamFactory, signal, }) {
-        const signedDataItem = await this.signer.signDataItem({
+    async uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
             fileStreamFactory,
+            fileSizeFactory,
         });
+        const signedDataItem = dataItemStreamFactory();
+        const fileSize = dataItemSizeFactory();
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -39,6 +44,7 @@ class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService
             data: signedDataItem,
             headers: {
                 'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
             },
         });
     }

package/lib/cjs/node/signer.js

@@ -30,10 +30,18 @@ class TurboNodeArweaveSigner {
         this.privateKey = privateKey;
         this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
     }
-    signDataItem({ fileStreamFactory, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: replace with our own signer implementation
         const [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
-        return (0, arbundles_1.streamSigner)(stream1, stream2, this.signer);
+        const signedDataItem = await (0, arbundles_1.streamSigner)(stream1, stream2, this.signer);
+        // TODO: support target, anchor, and tags
+        const signedDataItemSize = this.calculateSignedDataHeadersSize({
+            dataSize: fileSizeFactory(),
+        });
+        return {
+            dataItemStreamFactory: () => signedDataItem,
+            dataItemSizeFactory: () => signedDataItemSize,
+        };
     }
     // NOTE: this might be better in a parent class or elsewhere - easy enough to leave in here now and does require specific environment version of crypto
     async generateSignedRequestHeaders() {
@@ -46,5 +54,28 @@ class TurboNodeArweaveSigner {
             'x-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
         };
     }
+    // TODO: make dynamic that accepts anchor and target and tags to return the size of the headers + data
+    // reference https://github.com/ArweaveTeam/arweave-standards/blob/master/ans/ANS-104.md#13-dataitem-format
+    calculateSignedDataHeadersSize({ dataSize }) {
+        const anchor = 1; // + whatever they provide (max of 33)
+        const target = 1; // + whatever they provide (max of 33)
+        const tags = 0;
+        const signatureLength = 512;
+        const ownerLength = 512;
+        const signatureTypeLength = 2;
+        const numOfTagsLength = 8; // https://github.com/Bundlr-Network/arbundles/blob/master/src/tags.ts#L191-L198
+        const numOfTagsBytesLength = 8;
+        return [
+            anchor,
+            target,
+            tags,
+            signatureLength,
+            ownerLength,
+            signatureTypeLength,
+            numOfTagsLength,
+            numOfTagsBytesLength,
+            dataSize,
+        ].reduce((totalSize, currentSize) => (totalSize += currentSize));
+    }
 }
 exports.TurboNodeArweaveSigner = TurboNodeArweaveSigner;

package/lib/cjs/utils/readableStream.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readableStreamToBuffer = void 0;
-async function readableStreamToBuffer({ stream, }) {
+async function readableStreamToBuffer({ stream, size, }) {
     const reader = stream.getReader();
-    const chunks = [];
+    const buffer = Buffer.alloc(size);
+    let offset = 0;
     let done = false;
     while (!done) {
         const { done: streamDone, value } = await reader.read();
         done = streamDone;
         if (!done) {
-            chunks.push(value);
+            buffer.set(value, offset);
+            offset += value.byteLength;
         }
     }
-    return Buffer.concat(chunks);
+    return buffer;
 }
 exports.readableStreamToBuffer = readableStreamToBuffer;

package/lib/cjs/web/signer.js

@@ -30,15 +30,20 @@ class TurboWebArweaveSigner {
         this.privateKey = privateKey;
         this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
     }
-    async signDataItem({ fileStreamFactory, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
         const buffer = await (0, readableStream_js_1.readableStreamToBuffer)({
             stream: fileStreamFactory(),
-            // TODO: add payload size to get performance improvements
+            size: fileSizeFactory(),
         });
-        const signedDataItem = (0, arbundles_1.createData)(buffer, this.signer);
+        // TODO: support target, anchor and tags for upload
+        const signedDataItem = (0, arbundles_1.createData)(buffer, this.signer, {});
         await signedDataItem.sign(this.signer);
-        return signedDataItem.getRaw();
+        return {
+            // while this returns a Buffer - it needs to match our return type for uploading
+            dataItemStreamFactory: () => signedDataItem.getRaw(),
+            dataItemSizeFactory: () => signedDataItem.getRaw().length,
+        };
     }
     // NOTE: this might be better in a parent class or elsewhere - easy enough to leave in here now and does require specific environment version of crypto
     async generateSignedRequestHeaders() {

package/lib/esm/common/currency.js

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

package/lib/esm/common/index.js

@@ -17,3 +17,4 @@
 export * from './upload.js';
 export * from './payment.js';
 export * from './turbo.js';
+export * from './currency.js';

package/lib/esm/common/payment.js

@@ -6,22 +6,22 @@ export class TurboUnauthenticatedPaymentService {
             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',
         });
@@ -33,11 +33,34 @@ export 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);
+    }
 }
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
@@ -55,4 +78,13 @@ export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymen
         // 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());
+    }
 }

package/lib/esm/common/turbo.js

@@ -8,7 +8,7 @@ export class TurboUnauthenticatedClient {
     /**
      * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
      */
-    async getFiatToAR({ currency, }) {
+    getFiatToAR({ currency, }) {
         return this.paymentService.getFiatToAR({ currency });
     }
     /**
@@ -17,42 +17,49 @@ export class TurboUnauthenticatedClient {
      * 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({ bytes, }) {
+    getUploadCosts({ bytes, }) {
         return this.paymentService.getUploadCosts({ bytes });
     }
     /**
      * 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({ dataItemStreamFactory, signal, }) {
+    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);
+    }
 }
 export class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     constructor({ paymentService, uploadService, }) {
@@ -61,13 +68,17 @@ export class TurboAuthenticatedClient 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({ fileStreamFactory, signal, }) {
-        return this.uploadService.uploadFile({ fileStreamFactory, signal });
+    uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        return this.uploadService.uploadFile({
+            fileStreamFactory,
+            fileSizeFactory,
+            signal,
+        });
     }
 }

package/lib/esm/common/upload.js

@@ -6,7 +6,8 @@ export class TurboUnauthenticatedUploadService {
             retryConfig,
         });
     }
-    async uploadSignedDataItem({ dataItemStreamFactory, signal, }) {
+    async uploadSignedDataItem({ dataItemStreamFactory, dataItemSizeFactory, signal, }) {
+        const fileSize = dataItemSizeFactory();
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -14,6 +15,7 @@ export class TurboUnauthenticatedUploadService {
             data: dataItemStreamFactory(),
             headers: {
                 'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
             },
         });
     }
@@ -24,10 +26,13 @@ export class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadS
         super({ url, retryConfig });
         this.signer = signer;
     }
-    async uploadFile({ fileStreamFactory, signal, }) {
-        const signedDataItem = await this.signer.signDataItem({
+    async uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        const { dataItemStreamFactory, dataItemSizeFactory } = await this.signer.signDataItem({
             fileStreamFactory,
+            fileSizeFactory,
         });
+        const signedDataItem = dataItemStreamFactory();
+        const fileSize = dataItemSizeFactory();
         // TODO: add p-limit constraint or replace with separate upload class
         return this.httpService.post({
             endpoint: `/tx`,
@@ -35,6 +40,7 @@ export class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadS
             data: signedDataItem,
             headers: {
                 'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
             },
         });
     }

package/lib/esm/node/signer.js

@@ -24,10 +24,18 @@ export class TurboNodeArweaveSigner {
         this.privateKey = privateKey;
         this.signer = new ArweaveSigner(this.privateKey);
     }
-    signDataItem({ fileStreamFactory, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: replace with our own signer implementation
         const [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
-        return streamSigner(stream1, stream2, this.signer);
+        const signedDataItem = await streamSigner(stream1, stream2, this.signer);
+        // TODO: support target, anchor, and tags
+        const signedDataItemSize = this.calculateSignedDataHeadersSize({
+            dataSize: fileSizeFactory(),
+        });
+        return {
+            dataItemStreamFactory: () => signedDataItem,
+            dataItemSizeFactory: () => signedDataItemSize,
+        };
     }
     // NOTE: this might be better in a parent class or elsewhere - easy enough to leave in here now and does require specific environment version of crypto
     async generateSignedRequestHeaders() {
@@ -40,4 +48,27 @@ export class TurboNodeArweaveSigner {
             'x-signature': toB64Url(Buffer.from(signature)),
         };
     }
+    // TODO: make dynamic that accepts anchor and target and tags to return the size of the headers + data
+    // reference https://github.com/ArweaveTeam/arweave-standards/blob/master/ans/ANS-104.md#13-dataitem-format
+    calculateSignedDataHeadersSize({ dataSize }) {
+        const anchor = 1; // + whatever they provide (max of 33)
+        const target = 1; // + whatever they provide (max of 33)
+        const tags = 0;
+        const signatureLength = 512;
+        const ownerLength = 512;
+        const signatureTypeLength = 2;
+        const numOfTagsLength = 8; // https://github.com/Bundlr-Network/arbundles/blob/master/src/tags.ts#L191-L198
+        const numOfTagsBytesLength = 8;
+        return [
+            anchor,
+            target,
+            tags,
+            signatureLength,
+            ownerLength,
+            signatureTypeLength,
+            numOfTagsLength,
+            numOfTagsBytesLength,
+            dataSize,
+        ].reduce((totalSize, currentSize) => (totalSize += currentSize));
+    }
 }

package/lib/esm/utils/readableStream.js

@@ -1,13 +1,15 @@
-export async function readableStreamToBuffer({ stream, }) {
+export async function readableStreamToBuffer({ stream, size, }) {
     const reader = stream.getReader();
-    const chunks = [];
+    const buffer = Buffer.alloc(size);
+    let offset = 0;
     let done = false;
     while (!done) {
         const { done: streamDone, value } = await reader.read();
         done = streamDone;
         if (!done) {
-            chunks.push(value);
+            buffer.set(value, offset);
+            offset += value.byteLength;
         }
     }
-    return Buffer.concat(chunks);
+    return buffer;
 }

package/lib/esm/web/signer.js

@@ -24,15 +24,20 @@ export class TurboWebArweaveSigner {
         this.privateKey = privateKey;
         this.signer = new ArweaveSigner(this.privateKey);
     }
-    async signDataItem({ fileStreamFactory, }) {
+    async signDataItem({ fileStreamFactory, fileSizeFactory, }) {
         // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
         const buffer = await readableStreamToBuffer({
             stream: fileStreamFactory(),
-            // TODO: add payload size to get performance improvements
+            size: fileSizeFactory(),
         });
-        const signedDataItem = createData(buffer, this.signer);
+        // TODO: support target, anchor and tags for upload
+        const signedDataItem = createData(buffer, this.signer, {});
         await signedDataItem.sign(this.signer);
-        return signedDataItem.getRaw();
+        return {
+            // while this returns a Buffer - it needs to match our return type for uploading
+            dataItemStreamFactory: () => signedDataItem.getRaw(),
+            dataItemSizeFactory: () => signedDataItem.getRaw().length,
+        };
     }
     // NOTE: this might be better in a parent class or elsewhere - easy enough to leave in here now and does require specific environment version of crypto
     async generateSignedRequestHeaders() {

package/lib/types/common/currency.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 2022-2023 Permanent Data Solutions, Inc. All Rights Reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Currency } from '../types.js';
+export interface CurrencyMap {
+    amount: number;
+    type: Currency;
+}
+export declare class ZeroDecimalCurrency implements CurrencyMap {
+    readonly amount: number;
+    readonly type: Currency;
+    constructor(amount: number, type: Currency);
+}
+export declare class TwoDecimalCurrency implements CurrencyMap {
+    private a;
+    readonly type: Currency;
+    constructor(a: number, type: Currency);
+    get amount(): number;
+}
+export declare const USD: (usd: number) => TwoDecimalCurrency;
+export declare const EUR: (eur: number) => TwoDecimalCurrency;
+export declare const GBP: (gbp: number) => TwoDecimalCurrency;
+export declare const CAD: (cad: number) => TwoDecimalCurrency;
+export declare const AUD: (aud: number) => TwoDecimalCurrency;
+export declare const INR: (inr: number) => TwoDecimalCurrency;
+export declare const SGD: (sgd: number) => TwoDecimalCurrency;
+export declare const HKD: (hkd: number) => TwoDecimalCurrency;
+export declare const BRL: (brl: number) => TwoDecimalCurrency;
+export declare const JPY: (jpy: number) => ZeroDecimalCurrency;
+//# sourceMappingURL=currency.d.ts.map

package/lib/types/common/currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.d.ts","sourceRoot":"","sources":["../../../src/common/currency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,qBAAa,mBAAoB,YAAW,WAAW;aAEnC,MAAM,EAAE,MAAM;aACd,IAAI,EAAE,QAAQ;gBADd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,QAAQ;CAEjC;AAED,qBAAa,kBAAmB,YAAW,WAAW;IAElD,OAAO,CAAC,CAAC;aACO,IAAI,EAAE,QAAQ;gBADtB,CAAC,EAAE,MAAM,EACD,IAAI,EAAE,QAAQ;IAGhC,IAAI,MAAM,WAET;CACF;AAGD,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AACvE,eAAO,MAAM,GAAG,QAAS,MAAM,uBAAuC,CAAC;AAGvE,eAAO,MAAM,GAAG,QAAS,MAAM,wBAAwC,CAAC"}

package/lib/types/common/index.d.ts

@@ -17,4 +17,5 @@
 export * from './upload.js';
 export * from './payment.js';
 export * from './turbo.js';
+export * from './currency.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}