@ardrive/turbo-sdk 1.0.0-alpha.9 → 1.0.0-beta.2

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

@@ -6,8 +6,12 @@ const turbo_js_1 = require("./turbo.js");
 const upload_js_1 = require("./upload.js");
 class TurboBaseFactory {
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
-        const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService(Object.assign({}, paymentServiceConfig));
-        const uploadService = new upload_js_1.TurboUnauthenticatedUploadService(Object.assign({}, uploadServiceConfig));
+        const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({
+            ...paymentServiceConfig,
+        });
+        const uploadService = new upload_js_1.TurboUnauthenticatedUploadService({
+            ...uploadServiceConfig,
+        });
         return new turbo_js_1.TurboUnauthenticatedClient({
             uploadService,
             paymentService,

package/lib/cjs/common/http.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboHTTPService = void 0;
 const axiosClient_js_1 = require("../utils/axiosClient.js");
@@ -21,29 +12,25 @@ class TurboHTTPService {
             retryConfig,
         });
     }
-    get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { status, statusText, data } = yield this.axios.get(endpoint, {
-                headers,
-                signal,
-            });
-            if (!allowedStatuses.includes(status)) {
-                throw new errors_js_1.FailedRequestError(status, statusText);
-            }
-            return data;
+    async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
+        const { status, statusText, data } = await this.axios.get(endpoint, {
+            headers,
+            signal,
         });
+        if (!allowedStatuses.includes(status)) {
+            throw new errors_js_1.FailedRequestError(status, statusText);
+        }
+        return data;
     }
-    post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { status, statusText, data: response, } = yield this.axios.post(endpoint, data, {
-                headers,
-                signal,
-            });
-            if (!allowedStatuses.includes(status)) {
-                throw new errors_js_1.FailedRequestError(status, statusText);
-            }
-            return response;
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
+        const { status, statusText, data: response, } = await this.axios.post(endpoint, data, {
+            headers,
+            signal,
         });
+        if (!allowedStatuses.includes(status)) {
+            throw new errors_js_1.FailedRequestError(status, statusText);
+        }
+        return response;
     }
 }
 exports.TurboHTTPService = TurboHTTPService;

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,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = void 0;
 const http_js_1 = require("./http.js");
@@ -19,48 +10,59 @@ class TurboUnauthenticatedPaymentService {
         });
     }
     getFiatRates() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/rates',
-            });
+        return this.httpService.get({
+            endpoint: '/rates',
         });
     }
     getFiatToAR({ currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: `/rates/${currency}`,
-            });
+        return this.httpService.get({
+            endpoint: `/rates/${currency}`,
         });
     }
     getSupportedCountries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/countries',
-            });
+        return this.httpService.get({
+            endpoint: '/countries',
         });
     }
     getSupportedCurrencies() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: '/currencies',
-            });
+        return this.httpService.get({
+            endpoint: '/currencies',
         });
     }
-    getUploadCosts({ bytes, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fetchPricePromises = bytes.map((byteCount) => this.httpService.get({
-                endpoint: `/price/bytes/${byteCount}`,
-            }));
-            const wincCostsForBytes = yield Promise.all(fetchPricePromises);
-            return wincCostsForBytes;
+    async getUploadCosts({ bytes, }) {
+        const fetchPricePromises = bytes.map((byteCount) => this.httpService.get({
+            endpoint: `/price/bytes/${byteCount}`,
+        }));
+        const wincCostsForBytes = await Promise.all(fetchPricePromises);
+        return wincCostsForBytes;
+    }
+    getWincForFiat({ amount, }) {
+        const { amount: paymentAmount, type: currencyType } = amount;
+        return this.httpService.get({
+            endpoint: `/price/${currencyType}/${paymentAmount}`,
         });
     }
-    getWincForFiat({ amount, currency }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.httpService.get({
-                endpoint: `/price/${currency}/${amount}`,
-            });
+    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;
@@ -70,17 +72,24 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
         super({ url, retryConfig });
         this.signer = signer;
     }
-    getBalance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const headers = yield this.signer.generateSignedRequestHeaders();
-            const balance = yield this.httpService.get({
-                endpoint: '/balance',
-                headers,
-                allowedStatuses: [200, 404],
-            });
-            // 404's don't return a balance, so default to 0
-            return balance.winc ? balance : { winc: '0' };
+    async getBalance() {
+        const headers = await this.signer.generateSignedRequestHeaders();
+        const balance = await this.httpService.get({
+            endpoint: '/balance',
+            headers,
+            allowedStatuses: [200, 404],
         });
+        // 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;

package/lib/cjs/common/turbo.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedClient = exports.TurboUnauthenticatedClient = void 0;
 const payment_js_1 = require("./payment.js");
@@ -21,9 +12,7 @@ class TurboUnauthenticatedClient {
      * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
      */
     getFiatToAR({ currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getFiatToAR({ currency });
-        });
+        return this.paymentService.getFiatToAR({ currency });
     }
     /**
      * Returns the latest conversion rates to purchase 1GiB of data for all supported currencies, including all adjustments and fees.
@@ -32,53 +21,48 @@ class TurboUnauthenticatedClient {
      * cost in 'winc' for a given number of bytes, use getUploadCosts.
      */
     getFiatRates() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getFiatRates();
-        });
+        return this.paymentService.getFiatRates();
     }
     /**
      * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
      */
     getSupportedCountries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getSupportedCountries();
-        });
+        return this.paymentService.getSupportedCountries();
     }
     /**
      * Returns a list of all supported fiat currencies.
      */
     getSupportedCurrencies() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getSupportedCurrencies();
-        });
+        return this.paymentService.getSupportedCurrencies();
     }
     /**
      * Determines the price in 'winc' to upload one data item of a specific size in bytes, including all Turbo cost adjustments and fees.
      */
     getUploadCosts({ bytes, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.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.
      */
-    getWincForFiat({ amount, currency, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getWincForFiat({ amount, currency });
-        });
+    getWincForFiat(params) {
+        return this.paymentService.getWincForFiat(params);
     }
     /**
      * Uploads a signed data item to the Turbo Upload Service.
      */
-    uploadSignedDataItem({ dataItemStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.uploadService.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 {
@@ -89,16 +73,16 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
      * Returns the current balance of the user's wallet in 'winc'.
      */
     getBalance() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.paymentService.getBalance();
-        });
+        return this.paymentService.getBalance();
     }
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
      */
-    uploadFile({ fileStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.uploadService.uploadFile({ fileStreamFactory, signal });
+    uploadFile({ fileStreamFactory, fileSizeFactory, signal, }) {
+        return this.uploadService.uploadFile({
+            fileStreamFactory,
+            fileSizeFactory,
+            signal,
         });
     }
 }

package/lib/cjs/common/upload.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedUploadService = exports.TurboUnauthenticatedUploadService = void 0;
 const http_js_1 = require("./http.js");
@@ -18,17 +9,17 @@ class TurboUnauthenticatedUploadService {
             retryConfig,
         });
     }
-    uploadSignedDataItem({ dataItemStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: add p-limit constraint or replace with separate upload class
-            return this.httpService.post({
-                endpoint: `/tx`,
-                signal,
-                data: dataItemStreamFactory(),
-                headers: {
-                    'content-type': 'application/octet-stream',
-                },
-            });
+    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`,
+            signal,
+            data: dataItemStreamFactory(),
+            headers: {
+                'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
+            },
         });
     }
 }
@@ -39,20 +30,22 @@ class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService
         super({ url, retryConfig });
         this.signer = signer;
     }
-    uploadFile({ fileStreamFactory, signal, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signedDataItem = yield this.signer.signDataItem({
-                fileStreamFactory,
-            });
-            // TODO: add p-limit constraint or replace with separate upload class
-            return this.httpService.post({
-                endpoint: `/tx`,
-                signal,
-                data: signedDataItem,
-                headers: {
-                    'content-type': 'application/octet-stream',
-                },
-            });
+    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`,
+            signal,
+            data: signedDataItem,
+            headers: {
+                'content-type': 'application/octet-stream',
+                'content-length': `${fileSize}`,
+            },
         });
     }
 }

package/lib/cjs/node/factory.js

@@ -23,8 +23,14 @@ const signer_js_1 = require("./signer.js");
 class TurboFactory extends factory_js_1.TurboBaseFactory {
     static authenticated({ privateKey, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
         const signer = new signer_js_1.TurboNodeArweaveSigner({ privateKey });
-        const paymentService = new index_js_1.TurboAuthenticatedPaymentService(Object.assign(Object.assign({}, paymentServiceConfig), { signer }));
-        const uploadService = new index_js_1.TurboAuthenticatedUploadService(Object.assign(Object.assign({}, uploadServiceConfig), { signer }));
+        const paymentService = new index_js_1.TurboAuthenticatedPaymentService({
+            ...paymentServiceConfig,
+            signer,
+        });
+        const uploadService = new index_js_1.TurboAuthenticatedUploadService({
+            ...uploadServiceConfig,
+            signer,
+        });
         return new index_js_1.TurboAuthenticatedClient({
             uploadService,
             paymentService,

package/lib/cjs/node/index.js

@@ -32,5 +32,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./factory.js"), exports);
 __exportStar(require("./signer.js"), exports);
+__exportStar(require("../types.js"), exports);
 __exportStar(require("../common/index.js"), exports);
-__exportStar(require("../types/index.js"), exports);

package/lib/cjs/node/signer.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -39,23 +30,52 @@ 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
-    generateSignedRequestHeaders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const nonce = (0, node_crypto_1.randomBytes)(16).toString('hex');
-            const buffer = Buffer.from(nonce);
-            const signature = yield index_js_1.default.crypto.sign(this.privateKey, buffer);
-            return {
-                'x-public-key': this.privateKey.n,
-                'x-nonce': nonce,
-                'x-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
-            };
-        });
+    async generateSignedRequestHeaders() {
+        const nonce = (0, node_crypto_1.randomBytes)(16).toString('hex');
+        const buffer = Buffer.from(nonce);
+        const signature = await index_js_1.default.crypto.sign(this.privateKey, buffer);
+        return {
+            'x-public-key': this.privateKey.n,
+            'x-nonce': nonce,
+            '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/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/lib/cjs/utils/axiosClient.js

@@ -43,18 +43,27 @@ exports.createAxiosInstance = void 0;
  * 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/>.
  */
-const axios_1 = __importDefault(require("axios"));
-const rax = __importStar(require("retry-axios"));
+const axios_1 = __importStar(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
 const createAxiosInstance = ({ axiosConfig = {}, retryConfig = {
-    backoffType: 'exponential',
-    retry: 3,
-    onRetryAttempt: (err) => {
-        const cfg = rax.getConfig(err);
-        console.debug(`Retry attempt #${cfg === null || cfg === void 0 ? void 0 : cfg.currentRetryAttempt}`);
+    retryDelay: axios_retry_1.default.exponentialDelay,
+    retries: 3,
+    retryCondition: (error) => {
+        return (!(error instanceof axios_1.CanceledError) &&
+            axios_retry_1.default.isNetworkOrIdempotentRequestError(error));
+    },
+    onRetry: (retryCount, error) => {
+        console.debug(`Request failed, ${error}. Retry attempt #${retryCount}...`);
     },
 }, }) => {
-    const axiosInstance = axios_1.default.create(Object.assign(Object.assign({}, axiosConfig), { validateStatus: () => true }));
-    axiosInstance.defaults.raxConfig = Object.assign({ instance: axiosInstance }, retryConfig);
+    const axiosInstance = axios_1.default.create({
+        ...axiosConfig,
+        validateStatus: () => true, // don't throw on non-200 status codes
+    });
+    // eslint-disable-next-line
+    if (retryConfig.retries && retryConfig.retries > 0) {
+        (0, axios_retry_1.default)(axiosInstance, retryConfig);
+    }
     return axiosInstance;
 };
 exports.createAxiosInstance = createAxiosInstance;

package/lib/cjs/utils/readableStream.js

@@ -1,28 +1,19 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readableStreamToBuffer = void 0;
-function readableStreamToBuffer({ stream, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const reader = stream.getReader();
-        const chunks = [];
-        let done = false;
-        while (!done) {
-            const { done: streamDone, value } = yield reader.read();
-            done = streamDone;
-            if (!done) {
-                chunks.push(value);
-            }
+async function readableStreamToBuffer({ stream, size, }) {
+    const reader = stream.getReader();
+    const buffer = Buffer.alloc(size);
+    let offset = 0;
+    let done = false;
+    while (!done) {
+        const { done: streamDone, value } = await reader.read();
+        done = streamDone;
+        if (!done) {
+            buffer.set(value, offset);
+            offset += value.byteLength;
         }
-        return Buffer.concat(chunks);
-    });
+    }
+    return buffer;
 }
 exports.readableStreamToBuffer = readableStreamToBuffer;