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

package/lib/cjs/types/turbo.d.ts

@@ -0,0 +1,149 @@
+/// <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 { Readable } from 'node:stream';
+import { ReadableStream } from 'node:stream/web';
+import { RetryConfig } from 'retry-axios';
+import winston from 'winston';
+import { JWKInterface } from './arweave.js';
+export type Base64String = string;
+export type PublicArweaveAddress = Base64String;
+export type TransactionId = Base64String;
+export type UserAddress = string | PublicArweaveAddress;
+export type Currency = 'usd' | 'eur' | 'gbp' | 'cad' | 'aud' | 'nzd' | 'jpy';
+export type Country = 'United States' | 'United Kingdom' | 'Canada';
+export type CurrencyLimit = {
+    minimumPaymentAmount: number;
+    maximumPaymentAmount: number;
+    suggestedPaymentAmount: number[];
+    zeroDecimalCurrency: boolean;
+};
+export type TurboPriceResponse = {
+    winc: string;
+    adjustments: any;
+};
+export type TurboBalanceResponse = Omit<TurboPriceResponse, 'adjustments'>;
+export type TurboFiatToArResponse = {
+    currency: Currency;
+    rate: number;
+};
+export type TurboRatesResponse = TurboPriceResponse & Record<'fiat', Record<Currency, number>>;
+export type TurboCountriesResponse = Country[];
+export type TurboCurrenciesResponse = {
+    supportedCurrencies: Currency[];
+    limits: Record<Currency, CurrencyLimit>;
+};
+export type TurboUploadDataItemResponse = {
+    dataCaches: string[];
+    fastFinalityIndexes: string[];
+    id: TransactionId;
+    owner: PublicArweaveAddress;
+};
+export type TurboWallet = JWKInterface;
+export type TurboSignedRequestHeaders = {
+    'x-public-key': string;
+    'x-nonce': string;
+    'x-signature': string;
+};
+type TurboAuthConfiguration = {
+    signer: TurboWalletSigner;
+};
+type TurboServiceConfiguration = {
+    url?: string;
+    retryConfig?: RetryConfig;
+    logger?: winston.Logger;
+};
+export type TurboUnauthenticatedUploadServiceInterfaceConfiguration = TurboServiceConfiguration;
+export type TurboAuthenticatedUploadServiceConfiguration = TurboUnauthenticatedUploadServiceInterfaceConfiguration & TurboAuthConfiguration;
+export type TurboUnauthenticatedPaymentServiceInterfaceConfiguration = TurboServiceConfiguration;
+export type TurboAuthenticatedPaymentServiceInterfaceConfiguration = TurboServiceConfiguration & TurboAuthConfiguration;
+export type TurboPublicConfiguration = {
+    paymentServiceConfig?: TurboUnauthenticatedPaymentServiceInterfaceConfiguration;
+    uploadServiceConfig?: TurboUnauthenticatedUploadServiceInterfaceConfiguration;
+};
+export type TurboPrivateConfiguration = TurboPublicConfiguration & {
+    privateKey: TurboWallet;
+};
+export type TurboPublicClientConfiguration = {
+    paymentService: TurboUnauthenticatedPaymentServiceInterface;
+    uploadService: TurboUnauthenticatedUploadServiceInterface;
+};
+export type TurboPrivateClientConfiguration = {
+    paymentService: TurboAuthenticatedPaymentServiceInterface;
+    uploadService: TurboAuthenticatedUploadServiceInterface;
+};
+export type FileStreamFactory = (() => Readable) | (() => ReadableStream) | (() => Buffer);
+export type SignedDataStreamFactory = FileStreamFactory;
+export type TurboFileFactory = {
+    fileStreamFactory: FileStreamFactory;
+};
+export type TurboSignedDataItemFactory = {
+    dataItemStreamFactory: SignedDataStreamFactory;
+};
+export type TurboAbortSignal = {
+    signal?: AbortSignal;
+};
+export interface TurboHTTPServiceInterface {
+    get<T>({ endpoint, signal, headers, allowedStatuses, }: {
+        endpoint: string;
+        signal?: AbortSignal;
+        headers?: Partial<TurboSignedRequestHeaders> & Record<string, string>;
+        allowedStatuses?: number[];
+    }): Promise<T>;
+    post<T>({ endpoint, signal, headers, allowedStatuses, data, }: {
+        endpoint: string;
+        signal: AbortSignal;
+        headers?: Partial<TurboSignedRequestHeaders> & Record<string, string>;
+        allowedStatuses?: number[];
+        data: Readable | ReadableStream | Buffer;
+    }): Promise<T>;
+}
+export interface TurboWalletSigner {
+    signDataItem({ fileStreamFactory, }: TurboFileFactory): Promise<Readable> | Promise<Buffer>;
+    generateSignedRequestHeaders(): Promise<TurboSignedRequestHeaders>;
+}
+export interface TurboUnauthenticatedPaymentServiceInterface {
+    getSupportedCurrencies(): Promise<TurboCurrenciesResponse>;
+    getSupportedCountries(): Promise<TurboCountriesResponse>;
+    getFiatToAR({ currency, }: {
+        currency: Currency;
+    }): Promise<TurboFiatToArResponse>;
+    getFiatRates(): Promise<TurboRatesResponse>;
+    getWincForFiat({ amount, currency, }: {
+        amount: number;
+        currency: Currency;
+    }): Promise<Omit<TurboPriceResponse, 'adjustments'>>;
+    getUploadCosts({ bytes }: {
+        bytes: number[];
+    }): Promise<TurboPriceResponse[]>;
+}
+export interface TurboAuthenticatedPaymentServiceInterface extends TurboUnauthenticatedPaymentServiceInterface {
+    getBalance: () => Promise<TurboBalanceResponse>;
+}
+export interface TurboUnauthenticatedUploadServiceInterface {
+    uploadSignedDataItem({ dataItemStreamFactory, signal, }: TurboSignedDataItemFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}
+export interface TurboAuthenticatedUploadServiceInterface extends TurboUnauthenticatedUploadServiceInterface {
+    uploadFile({ fileStreamFactory, }: TurboFileFactory & TurboAbortSignal): Promise<TurboUploadDataItemResponse>;
+}
+export interface TurboUnauthenticatedClientInterface extends TurboUnauthenticatedPaymentServiceInterface, TurboUnauthenticatedUploadServiceInterface {
+}
+export interface TurboAuthenticatedClientInterface extends TurboAuthenticatedPaymentServiceInterface, TurboAuthenticatedUploadServiceInterface {
+}
+export {};

package/lib/cjs/types/turbo.js

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

package/lib/cjs/utils/axiosClient.js

@@ -0,0 +1,60 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAxiosInstance = 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 axios_1 = __importDefault(require("axios"));
+const rax = __importStar(require("retry-axios"));
+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}`);
+    },
+}, }) => {
+    const axiosInstance = axios_1.default.create(Object.assign(Object.assign({}, axiosConfig), { validateStatus: () => true }));
+    axiosInstance.defaults.raxConfig = Object.assign({ instance: axiosInstance }, retryConfig);
+    return axiosInstance;
+};
+exports.createAxiosInstance = createAxiosInstance;

package/lib/cjs/utils/base64.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { JWKInterface } from '../types/index.js';
+import { Base64String, PublicArweaveAddress } from '../types/index.js';
+export declare const base64URLRegex: RegExp;
+export declare function jwkToPublicArweaveAddress(jwk: JWKInterface): PublicArweaveAddress;
+export declare function ownerToAddress(owner: Base64String): PublicArweaveAddress;
+export declare function fromB64Url(input: Base64String): Buffer;
+export declare function toB64Url(buffer: Buffer): Base64String;
+export declare function sha256B64Url(input: Buffer): Base64String;

package/lib/cjs/utils/base64.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256B64Url = exports.toB64Url = exports.fromB64Url = exports.ownerToAddress = exports.jwkToPublicArweaveAddress = exports.base64URLRegex = 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 utils_js_1 = require("arweave/node/lib/utils.js");
+const crypto_1 = require("crypto");
+exports.base64URLRegex = /^[a-zA-Z0-9_-]{43}$/;
+function jwkToPublicArweaveAddress(jwk) {
+    return ownerToAddress(jwk.n);
+}
+exports.jwkToPublicArweaveAddress = jwkToPublicArweaveAddress;
+function ownerToAddress(owner) {
+    return sha256B64Url(fromB64Url(owner));
+}
+exports.ownerToAddress = ownerToAddress;
+function fromB64Url(input) {
+    const paddingLength = input.length % 4 === 0 ? 0 : 4 - (input.length % 4);
+    const base64 = input
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
+        .concat('='.repeat(paddingLength));
+    return Buffer.from(base64, 'base64');
+}
+exports.fromB64Url = fromB64Url;
+function toB64Url(buffer) {
+    return (0, utils_js_1.bufferTob64Url)(buffer);
+}
+exports.toB64Url = toB64Url;
+function sha256B64Url(input) {
+    return toB64Url((0, crypto_1.createHash)('sha256').update(input).digest());
+}
+exports.sha256B64Url = sha256B64Url;

package/lib/cjs/utils/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedRequestError = exports.UnauthenticatedRequestError = 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/>.
+ */
+class UnauthenticatedRequestError extends Error {
+    constructor() {
+        super('Failed authentication. JWK is required.');
+        this.name = 'UnauthenticatedRequestError';
+    }
+}
+exports.UnauthenticatedRequestError = UnauthenticatedRequestError;
+class FailedRequestError extends Error {
+    constructor(status, message) {
+        super(`Failed request: ${status}: ${message}`);
+        this.name = 'FailedRequestError';
+    }
+}
+exports.FailedRequestError = FailedRequestError;

package/lib/cjs/utils/readableStream.d.ts

@@ -0,0 +1,22 @@
+/// <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 { ReadableStream } from 'node:stream/web';
+export declare function readableStreamToBuffer({ stream, }: {
+    stream: ReadableStream;
+}): Promise<Buffer>;

package/lib/cjs/utils/readableStream.js

@@ -0,0 +1,28 @@
+"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);
+            }
+        }
+        return Buffer.concat(chunks);
+    });
+}
+exports.readableStreamToBuffer = readableStreamToBuffer;

package/lib/cjs/web/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.TurboWebArweaveSigner({ 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/web/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/web/signer.d.ts

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

package/lib/cjs/web/signer.js

@@ -0,0 +1,69 @@
+"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.TurboWebArweaveSigner = 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 arweave_1 = __importDefault(require("arweave"));
+const node_crypto_1 = require("node:crypto");
+const base64_js_1 = require("../utils/base64.js");
+const readableStream_js_1 = require("../utils/readableStream.js");
+class TurboWebArweaveSigner {
+    constructor({ privateKey }) {
+        this.privateKey = privateKey;
+        this.signer = new arbundles_1.ArweaveSigner(this.privateKey);
+    }
+    signDataItem({ fileStreamFactory, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
+            const buffer = yield (0, readableStream_js_1.readableStreamToBuffer)({
+                stream: fileStreamFactory(),
+                // TODO: add payload size to get performance improvements
+            });
+            const signedDataItem = (0, arbundles_1.createData)(buffer, this.signer);
+            yield signedDataItem.sign(this.signer);
+            return signedDataItem.getRaw();
+        });
+    }
+    // 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);
+            // a bit hacky - but easiest way to solve web signing issues while still building for cjs
+            const signature = yield arweave_1.default.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.TurboWebArweaveSigner = TurboWebArweaveSigner;

package/lib/esm/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/esm/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/esm/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>;
+}