@ardrive/turbo-sdk 1.0.0-alpha.5 → 1.0.0-alpha.6

package/lib/cjs/common/factory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboBaseFactory = void 0;
+const payment_js_1 = require("./payment.js");
+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));
+        return new turbo_js_1.TurboUnauthenticatedClient({
+            uploadService,
+            paymentService,
+        });
+    }
+}
+exports.TurboBaseFactory = TurboBaseFactory;

package/lib/cjs/common/http.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 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 { AxiosInstance } from 'axios';
+import { RetryConfig } from 'retry-axios';
+import { Readable } from 'stream';
+import { ReadableStream } from 'stream/web';
+import { TurboHTTPServiceInterface, TurboSignedRequestHeaders } from '../types/turbo.js';
+export declare class TurboHTTPService implements TurboHTTPServiceInterface {
+    protected axios: AxiosInstance;
+    constructor({ url, retryConfig, }: {
+        url: string;
+        retryConfig?: RetryConfig;
+    });
+    get<T>({ endpoint, signal, allowedStatuses, headers, }: {
+        endpoint: string;
+        signal?: AbortSignal;
+        allowedStatuses?: number[];
+        headers?: Partial<TurboSignedRequestHeaders> & Record<string, string>;
+    }): Promise<T>;
+    post<T>({ endpoint, signal, allowedStatuses, headers, data, }: {
+        endpoint: string;
+        signal?: AbortSignal;
+        allowedStatuses?: number[];
+        headers?: Partial<TurboSignedRequestHeaders> & Record<string, string>;
+        data: Readable | Buffer | ReadableStream;
+    }): Promise<T>;
+}

package/lib/cjs/common/http.js

@@ -0,0 +1,49 @@
+"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");
+const errors_js_1 = require("../utils/errors.js");
+class TurboHTTPService {
+    constructor({ url, retryConfig, }) {
+        this.axios = (0, axiosClient_js_1.createAxiosInstance)({
+            axiosConfig: {
+                baseURL: url,
+            },
+            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;
+        });
+    }
+    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;
+        });
+    }
+}
+exports.TurboHTTPService = TurboHTTPService;

package/lib/cjs/common/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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/>.
+ */
+__exportStar(require("./upload.js"), exports);
+__exportStar(require("./payment.js"), exports);
+__exportStar(require("./turbo.js"), exports);

package/lib/cjs/common/payment.js

@@ -0,0 +1,86 @@
+"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");
+class TurboUnauthenticatedPaymentService {
+    constructor({ url = 'https://payment.ardrive.dev', retryConfig, }) {
+        this.httpService = new http_js_1.TurboHTTPService({
+            url: `${url}/v1`,
+            retryConfig,
+        });
+    }
+    getFiatRates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpService.get({
+                endpoint: '/rates',
+            });
+        });
+    }
+    getFiatToAR({ currency, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpService.get({
+                endpoint: `/rates/${currency}`,
+            });
+        });
+    }
+    getSupportedCountries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpService.get({
+                endpoint: '/countries',
+            });
+        });
+    }
+    getSupportedCurrencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
+    getWincForFiat({ amount, currency }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpService.get({
+                endpoint: `/price/${currency}/${amount}`,
+            });
+        });
+    }
+}
+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, }) {
+        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' };
+        });
+    }
+}
+exports.TurboAuthenticatedPaymentService = TurboAuthenticatedPaymentService;

package/lib/cjs/common/turbo.js

@@ -0,0 +1,105 @@
+"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");
+const upload_js_1 = require("./upload.js");
+class TurboUnauthenticatedClient {
+    constructor({ uploadService = new upload_js_1.TurboUnauthenticatedUploadService({}), paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({}), }) {
+        this.paymentService = paymentService;
+        this.uploadService = uploadService;
+    }
+    /**
+     * 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 });
+        });
+    }
+    /**
+     * Returns the latest conversion rates to purchase 1GiB of data for all supported currencies, including all adjustments and fees.
+     *
+     * 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.
+     */
+    getFiatRates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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();
+        });
+    }
+    /**
+     * Returns a list of all supported fiat currencies.
+     */
+    getSupportedCurrencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 });
+        });
+    }
+    /**
+     * 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 });
+        });
+    }
+    /**
+     * 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,
+            });
+        });
+    }
+}
+exports.TurboUnauthenticatedClient = TurboUnauthenticatedClient;
+class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
+    constructor({ paymentService, uploadService, }) {
+        super({ paymentService, uploadService });
+    }
+    /**
+     * Returns the current balance of the user's wallet in 'winc'.
+     */
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 });
+        });
+    }
+}
+exports.TurboAuthenticatedClient = TurboAuthenticatedClient;

package/lib/cjs/common/upload.js

@@ -0,0 +1,59 @@
+"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");
+class TurboUnauthenticatedUploadService {
+    constructor({ url = 'https://upload.ardrive.dev', retryConfig, }) {
+        this.httpService = new http_js_1.TurboHTTPService({
+            url: `${url}/v1`,
+            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',
+                },
+            });
+        });
+    }
+}
+exports.TurboUnauthenticatedUploadService = TurboUnauthenticatedUploadService;
+// NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
+class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService {
+    constructor({ url = 'https://upload.ardrive.dev', retryConfig, signer, }) {
+        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',
+                },
+            });
+        });
+    }
+}
+exports.TurboAuthenticatedUploadService = TurboAuthenticatedUploadService;

package/lib/cjs/node/factory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboFactory = void 0;
+/**
+ * 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/>.
+ */
+const factory_js_1 = require("../common/factory.js");
+const index_js_1 = require("../common/index.js");
+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 }));
+        return new index_js_1.TurboAuthenticatedClient({
+            uploadService,
+            paymentService,
+        });
+    }
+}
+exports.TurboFactory = TurboFactory;

package/lib/cjs/node/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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/>.
+ */
+__exportStar(require("./factory.js"), exports);
+__exportStar(require("./signer.js"), exports);
+__exportStar(require("../common/index.js"), exports);
+__exportStar(require("../types/index.js"), exports);

package/lib/cjs/node/signer.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/**
+ * 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 { ArweaveSigner } from 'arbundles';
+import { Readable } from 'node:stream';
+import { JWKInterface } from '../types/arweave.js';
+import { TurboWalletSigner } from '../types/turbo.js';
+export declare class TurboNodeArweaveSigner implements TurboWalletSigner {
+    protected privateKey: JWKInterface;
+    protected signer: ArweaveSigner;
+    constructor({ privateKey }: {
+        privateKey: JWKInterface;
+    });
+    signDataItem({ fileStreamFactory, }: {
+        fileStreamFactory: () => Readable;
+    }): Promise<Readable>;
+    generateSignedRequestHeaders(): Promise<{
+        'x-public-key': string;
+        'x-nonce': string;
+        'x-signature': string;
+    }>;
+}

package/lib/cjs/node/signer.js

@@ -0,0 +1,61 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboNodeArweaveSigner = void 0;
+/**
+ * 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/>.
+ */
+const arbundles_1 = require("arbundles");
+const index_js_1 = __importDefault(require("arweave/node/index.js"));
+const node_crypto_1 = require("node:crypto");
+const base64_js_1 = require("../utils/base64.js");
+class TurboNodeArweaveSigner {
+    // TODO: replace with internal signer class
+    constructor({ privateKey }) {
+        this.privateKey = privateKey;
+        this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
+    }
+    signDataItem({ fileStreamFactory, }) {
+        // TODO: replace with our own signer implementation
+        const [stream1, stream2] = [fileStreamFactory(), fileStreamFactory()];
+        return (0, arbundles_1.streamSigner)(stream1, stream2, this.signer);
+    }
+    // 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)),
+            };
+        });
+    }
+}
+exports.TurboNodeArweaveSigner = TurboNodeArweaveSigner;

package/lib/cjs/types/arweave.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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/>.
+ */
+__exportStar(require("./arweave.js"), exports);
+__exportStar(require("./turbo.js"), exports);