@ardrive/turbo-sdk 1.0.0-alpha.1

package/lib/README.md

@@ -0,0 +1,114 @@
+# @ardriveapp/turbo-sdk 🚀
+
+Welcome to the `@ardrive/turbo-sdk`! This SDK provides functionalities for interacting with the Turbo Upload and Payment Services. It is available in both NodeJS and Web environments.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage):
+
+  - [NodeJS Environments](#nodejs)
+    - [CommonJS](#commonjs)
+    - [ESM](#esm)
+  - [Web Environments](#web)
+    - [Bundlers (Webpack, Rollup, ESbuild, etc.)](#bundlers-webpack-rollup-esbuild-etc)
+    - [Browser](#browser)
+  - [Typescript](#typescript)
+  - [Examples](./examples)
+
+- [Contributions](#contributions)
+
+# Installation
+
+```shell
+npm install @ardrive/turbo-sdk
+```
+
+or
+
+```shell
+yarn add @ardrive/turbo-sdk
+```
+
+# Usage
+
+The SDK is available in both CommonJS and ESM formats and is compatible with bundlers such as Webpack, Rollup, and ESbuild.
+
+## Web
+
+# Bundlers (Webpack, Rollup, ESbuild, etc.)
+
+```javascript
+import { TurboFactory } from '@ardrive/turbo-sdk/web';
+
+const turbo = TurboFactory.unauthenticated({});
+const rates = await turbo.getFiatRates();
+```
+
+### Browser
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@ardrive/turbo-sdk"></script>
+<script>
+  const turbo = TurboFactory.unauthenticated({});
+  const rates = await turbo.getFiatRates();
+</script>
+```
+
+## NodeJS
+
+### CommonJS
+
+```javascript
+const { TurboFactory } = require('@ardrive/turbo-sdk/node');
+
+const turbo = TurboFactory.unauthenticated({});
+const rates = await turbo.getFiatRates();
+```
+
+### ESM
+
+```javascript
+import { TurboFactory } from '@ardrive/turbo-sdk/node';
+
+const turbo = TurboFactory.unauthenticated({});
+const rates = await turbo.getFiatRates();
+```
+
+## Typescript
+
+The SDK provides TypeScript typings. When you import the SDK in a TypeScript project:
+
+```typescript
+import Ardrive from '@ardrive/turbo-sdk/web';
+
+// or '@ardrive/turbo-sdk/node' for Node.js projects
+```
+
+The provided typings (`./lib/types/index.d.ts`) will be automatically recognized, offering type checking and autocompletion benefits.
+
+# APIs (WIP)
+
+## TurboFactory
+
+- `public()`
+- `private()`
+
+## TurboUnauthenticatedClient
+
+- `getFiatRates()`
+- `getFiatToAR()`
+- `getSupportedCountries()`
+- `getSupportedCurrencies()`
+- `getWincForFiat()`
+- `getUploadCosts()`
+- `uploadSignedDataItem()`
+
+## TurboAuthenticatedClient
+
+- `getBalance()`
+- `uploadFile()`
+
+# Contributions
+
+If you encounter any issues or have feature requests, please file an issue on our GitHub repository. Contributions, pull requests, and feedback are welcome and encouraged.

package/lib/common/factory.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { TurboPublicConfiguration } from '../types/turbo.js';
+import { TurboUnauthenticatedClient } from './turbo.js';
+export declare class TurboBaseFactory {
+    static unauthenticated({ paymentServiceConfig, uploadServiceConfig, }?: TurboPublicConfiguration): TurboUnauthenticatedClient;
+}

package/lib/common/factory.js

@@ -0,0 +1,13 @@
+import { TurboUnauthenticatedPaymentService } from './payment.js';
+import { TurboUnauthenticatedClient } from './turbo.js';
+import { TurboUnauthenticatedUploadService } from './upload.js';
+export class TurboBaseFactory {
+    static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, } = {}) {
+        const paymentService = new TurboUnauthenticatedPaymentService(Object.assign({}, paymentServiceConfig));
+        const uploadService = new TurboUnauthenticatedUploadService(Object.assign({}, uploadServiceConfig));
+        return new TurboUnauthenticatedClient({
+            uploadService,
+            paymentService,
+        });
+    }
+}

package/lib/common/http.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 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/common/http.js

@@ -0,0 +1,45 @@
+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());
+    });
+};
+import { createAxiosInstance } from '../utils/axiosClient.js';
+import { FailedRequestError } from '../utils/errors.js';
+export class TurboHTTPService {
+    constructor({ url, retryConfig, }) {
+        this.axios = 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 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 FailedRequestError(status, statusText);
+            }
+            return response;
+        });
+    }
+}

package/lib/common/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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/>.
+ */
+export * from './upload.js';
+export * from './payment.js';
+export * from './turbo.js';

package/lib/common/index.js

@@ -0,0 +1,19 @@
+/**
+ * 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/>.
+ */
+export * from './upload.js';
+export * from './payment.js';
+export * from './turbo.js';

package/lib/common/payment.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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, TurboAuthenticatedPaymentServiceInterface, TurboAuthenticatedPaymentServiceInterfaceConfiguration, TurboBalanceResponse, TurboCountriesResponse, TurboCurrenciesResponse, TurboFiatToArResponse, TurboPriceResponse, TurboRatesResponse, TurboUnauthenticatedPaymentServiceInterface, TurboUnauthenticatedPaymentServiceInterfaceConfiguration, TurboWalletSigner } from '../types/turbo.js';
+import { TurboHTTPService } from './http.js';
+export declare class TurboUnauthenticatedPaymentService implements TurboUnauthenticatedPaymentServiceInterface {
+    protected readonly httpService: TurboHTTPService;
+    constructor({ url, retryConfig, }: TurboUnauthenticatedPaymentServiceInterfaceConfiguration);
+    getFiatRates(): Promise<TurboRatesResponse>;
+    getFiatToAR({ currency, }: {
+        currency: Currency;
+    }): Promise<TurboFiatToArResponse>;
+    getSupportedCountries(): Promise<TurboCountriesResponse>;
+    getSupportedCurrencies(): Promise<TurboCurrenciesResponse>;
+    getUploadCosts({ bytes, }: {
+        bytes: number[];
+    }): Promise<TurboPriceResponse[]>;
+    getWincForFiat({ amount, currency }: {
+        amount: any;
+        currency: any;
+    }): Promise<TurboPriceResponse>;
+}
+export declare class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService implements TurboAuthenticatedPaymentServiceInterface {
+    protected readonly httpService: TurboHTTPService;
+    protected readonly signer: TurboWalletSigner;
+    constructor({ url, retryConfig, signer, }: TurboAuthenticatedPaymentServiceInterfaceConfiguration);
+    getBalance(): Promise<TurboBalanceResponse>;
+}

package/lib/common/payment.js

@@ -0,0 +1,81 @@
+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());
+    });
+};
+import { TurboHTTPService } from './http.js';
+export class TurboUnauthenticatedPaymentService {
+    constructor({ url = 'https://payment.ardrive.dev', retryConfig, }) {
+        this.httpService = new 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}`,
+            });
+        });
+    }
+}
+// NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
+export 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' };
+        });
+    }
+}

package/lib/common/turbo.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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, TurboAbortSignal, TurboAuthenticatedClientInterface, TurboAuthenticatedPaymentServiceInterface, TurboAuthenticatedUploadServiceInterface, TurboBalanceResponse, TurboCountriesResponse, TurboCurrenciesResponse, TurboFiatToArResponse, TurboFileFactory, TurboPriceResponse, TurboPrivateClientConfiguration, TurboPublicClientConfiguration, TurboRatesResponse, TurboSignedDataItemFactory, TurboUnauthenticatedClientInterface, TurboUnauthenticatedPaymentServiceInterface, TurboUnauthenticatedUploadServiceInterface, TurboUploadDataItemResponse } from '../types/index.js';
+export declare class TurboUnauthenticatedClient implements TurboUnauthenticatedClientInterface {
+    protected readonly paymentService: TurboUnauthenticatedPaymentServiceInterface;
+    protected readonly uploadService: TurboUnauthenticatedUploadServiceInterface;
+    constructor({ uploadService, paymentService, }: TurboPublicClientConfiguration);
+    /**
+     * Returns the supported fiat currency conversion rate for 1AR based on current market prices.
+     */
+    getFiatToAR({ currency, }: {
+        currency: Currency;
+    }): Promise<TurboFiatToArResponse>;
+    /**
+     * 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(): Promise<TurboRatesResponse>;
+    /**
+     * Returns a comprehensive list of supported countries that can purchase credits through the Turbo Payment Service.
+     */
+    getSupportedCountries(): Promise<TurboCountriesResponse>;
+    /**
+     * Returns a list of all supported fiat currencies.
+     */
+    getSupportedCurrencies(): Promise<TurboCurrenciesResponse>;
+    /**
+     * 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, }: {
+        bytes: number[];
+    }): Promise<TurboPriceResponse[]>;
+    /**
+     * 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, }: {
+        amount: number;
+        currency: Currency;
+    }): Promise<Omit<TurboPriceResponse, 'adjustments'>>;
+    /**
+     * Uploads a signed data item to the Turbo Upload Service.
+     */
+    uploadSignedDataItem({ dataItemStreamFactory, signal, }: TurboSignedDataItemFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}
+export declare class TurboAuthenticatedClient extends TurboUnauthenticatedClient implements TurboAuthenticatedClientInterface {
+    protected readonly paymentService: TurboAuthenticatedPaymentServiceInterface;
+    protected readonly uploadService: TurboAuthenticatedUploadServiceInterface;
+    constructor({ paymentService, uploadService, }: TurboPrivateClientConfiguration);
+    /**
+     * Returns the current balance of the user's wallet in 'winc'.
+     */
+    getBalance(): Promise<TurboBalanceResponse>;
+    /**
+     * Signs and uploads raw data to the Turbo Upload Service.
+     */
+    uploadFile({ fileStreamFactory, signal, }: TurboFileFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}

package/lib/common/turbo.js

@@ -0,0 +1,100 @@
+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());
+    });
+};
+import { TurboUnauthenticatedPaymentService } from './payment.js';
+import { TurboUnauthenticatedUploadService } from './upload.js';
+export class TurboUnauthenticatedClient {
+    constructor({ uploadService = new TurboUnauthenticatedUploadService({}), paymentService = new 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,
+            });
+        });
+    }
+}
+export 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 });
+        });
+    }
+}

package/lib/common/upload.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { TurboAbortSignal, TurboAuthenticatedUploadServiceConfiguration, TurboAuthenticatedUploadServiceInterface, TurboFileFactory, TurboSignedDataItemFactory, TurboUnauthenticatedUploadServiceInterface, TurboUnauthenticatedUploadServiceInterfaceConfiguration, TurboUploadDataItemResponse, TurboWalletSigner } from '../types/turbo.js';
+import { TurboHTTPService } from './http.js';
+export declare class TurboUnauthenticatedUploadService implements TurboUnauthenticatedUploadServiceInterface {
+    protected httpService: TurboHTTPService;
+    constructor({ url, retryConfig, }: TurboUnauthenticatedUploadServiceInterfaceConfiguration);
+    uploadSignedDataItem({ dataItemStreamFactory, signal, }: TurboSignedDataItemFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}
+export declare class TurboAuthenticatedUploadService extends TurboUnauthenticatedUploadService implements TurboAuthenticatedUploadServiceInterface {
+    protected httpService: TurboHTTPService;
+    protected signer: TurboWalletSigner;
+    constructor({ url, retryConfig, signer, }: TurboAuthenticatedUploadServiceConfiguration);
+    uploadFile({ fileStreamFactory, signal, }: TurboFileFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}

package/lib/common/upload.js

@@ -0,0 +1,54 @@
+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());
+    });
+};
+import { TurboHTTPService } from './http.js';
+export class TurboUnauthenticatedUploadService {
+    constructor({ url = 'https://upload.ardrive.dev', retryConfig, }) {
+        this.httpService = new 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',
+                },
+            });
+        });
+    }
+}
+// NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
+export 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',
+                },
+            });
+        });
+    }
+}