@ardrive/turbo-sdk 1.36.0 → 1.37.0-alpha.2

package/lib/cjs/common/winstonLogger.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboWinstonLogger = void 0;
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const version_js_1 = require("../version.js");
+class TurboWinstonLogger {
+    constructor({ level = 'info', } = {}) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            this.winston = require('winston');
+        }
+        catch (error) {
+            throw new Error('Winston is not installed. Install it with: npm install winston');
+        }
+        this.logger = this.winston.createLogger({
+            level: level === 'none' ? 'error' : level,
+            silent: level === 'none',
+            defaultMeta: {
+                name: 'ar-io-sdk',
+                version: version_js_1.version,
+            },
+            format: this.winston.format.combine(this.winston.format.timestamp(), this.winston.format.json()),
+            transports: [
+                new this.winston.transports.Console({
+                    format: this.winston.format.combine(this.winston.format.timestamp(), this.winston.format.json()),
+                }),
+            ],
+        });
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    setLogLevel(level) {
+        if (level === 'none') {
+            this.logger.silent = true;
+        }
+        else {
+            this.logger.silent = false;
+            this.logger.level = level;
+        }
+    }
+}
+exports.TurboWinstonLogger = TurboWinstonLogger;

package/lib/cjs/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.OnDemandFunding = exports.ExistingBalanceFunding = exports.supportedEvmSignerTokens = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
+exports.validChunkingModes = exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderParams = exports.multipartFinalizedStatus = exports.multipartFailedStatus = exports.multipartPendingStatus = exports.X402Funding = exports.OnDemandFunding = exports.ExistingBalanceFunding = exports.supportedEvmSignerTokens = exports.tokenTypes = exports.fiatCurrencyTypes = void 0;
 exports.isCurrency = isCurrency;
 exports.isKyvePrivateKey = isKyvePrivateKey;
 exports.isEthPrivateKey = isEthPrivateKey;
@@ -62,6 +62,14 @@ class OnDemandFunding {
     }
 }
 exports.OnDemandFunding = OnDemandFunding;
+class X402Funding {
+    constructor({ signer, maxMUSDCAmount, }) {
+        this.signer = signer;
+        this.maxMUSDCAmount =
+            maxMUSDCAmount !== undefined ? new bignumber_js_1.BigNumber(maxMUSDCAmount) : undefined;
+    }
+}
+exports.X402Funding = X402Funding;
 exports.multipartPendingStatus = [
     'ASSEMBLING',
     'VALIDATING',

package/lib/cjs/utils/axiosClient.js

@@ -26,7 +26,7 @@ exports.defaultRequestHeaders = {
     'x-turbo-source-version': version_js_1.version,
     'x-turbo-source-identifier': 'turbo-sdk',
 };
-const defaultRetryConfig = (logger = logger_js_1.TurboWinstonLogger.default) => ({
+const defaultRetryConfig = (logger = logger_js_1.Logger.default) => ({
     retryDelay: (retryCount) => Math.min(1000 * 2 ** (retryCount - 1), 30 * 1000), // exponential backoff up to 30s
     retries: 5,
     onRetry: (retryCount, error) => {

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '1.36.0';
+exports.version = '1.37.0-alpha.2';

package/lib/esm/cli/options.js

@@ -183,6 +183,11 @@ export const optionMap = {
         description: 'Enable on-demand crypto top-ups during upload if balance is insufficient',
         default: false,
     },
+    x402: {
+        alias: '--x402',
+        description: 'Pay for the action using x402 funding (if available). Requires token `base-usdc`.',
+        default: false,
+    },
     topUpBufferMultiplier: {
         alias: '--top-up-buffer-multiplier <topUpBufferMultiplier>',
         description: 'Multiplier to apply to the estimated top-up amount to avoid underpayment during on-demand top-ups. Defaults to 1.1 (10% buffer).',
@@ -212,6 +217,7 @@ const onDemandOptions = [
     optionMap.onDemand,
     optionMap.topUpBufferMultiplier,
     optionMap.maxCryptoTopUpValue,
+    optionMap.x402,
 ];
 export const uploadOptions = [
     ...walletOptions,

package/lib/esm/cli/utils.js

@@ -15,7 +15,7 @@
  */
 import bs58 from 'bs58';
 import { readFileSync, statSync } from 'fs';
-import { ExistingBalanceFunding, OnDemandFunding, TurboFactory, defaultTurboConfiguration, developmentTurboConfiguration, fiatCurrencyTypes, isCurrency, isTokenType, privateKeyFromKyveMnemonic, tokenToBaseMap, } from '../node/index.js';
+import { ExistingBalanceFunding, OnDemandFunding, TurboFactory, X402Funding, defaultTurboConfiguration, developmentTurboConfiguration, fiatCurrencyTypes, isCurrency, isTokenType, privateKeyFromKyveMnemonic, tokenToBaseMap, } from '../node/index.js';
 import { defaultProdAoConfigs, tokenToDevAoConfigMap, tokenToDevGatewayMap, } from '../utils/common.js';
 import { NoWalletProvidedError } from './errors.js';
 export function exitWithErrorLog(error) {
@@ -246,7 +246,10 @@ export function getTagsFromOptions(options) {
     return parseTags(options.tags);
 }
 export function onDemandOptionsFromOptions(options) {
-    if (!options.onDemand) {
+    if (options.x402 && options.onDemand) {
+        throw new Error('Cannot use both --x402 and --on-demand flags');
+    }
+    if (!options.onDemand && !options.x402) {
         return { fundingMode: new ExistingBalanceFunding() };
     }
     const value = options.maxCryptoTopUpValue;
@@ -258,6 +261,11 @@ export function onDemandOptionsFromOptions(options) {
         const token = tokenFromOptions(options);
         maxTokenAmount = tokenToBaseMap[token](value).toString();
     }
+    if (options.x402) {
+        return {
+            fundingMode: new X402Funding({ maxMUSDCAmount: maxTokenAmount }),
+        };
+    }
     if (options.topUpBufferMultiplier !== undefined &&
         (isNaN(options.topUpBufferMultiplier) || options.topUpBufferMultiplier < 1)) {
         throw new Error('topUpBufferMultiplier must be a number >= 1');

package/lib/esm/common/chunked.js

@@ -19,7 +19,7 @@ import { multipartFailedStatus, validChunkingModes, } from '../types.js';
 import { sleep } from '../utils/common.js';
 import { FailedRequestError } from '../utils/errors.js';
 import { TurboEventEmitter, createStreamWithUploadEvents } from './events.js';
-import { TurboWinstonLogger } from './logger.js';
+import { Logger } from './logger.js';
 const fiveMiB = 5 * 1024 * 1024; // 5 MiB
 const fiveHundredMiB = fiveMiB * 100; // 500 MiB
 export const defaultMaxChunkConcurrency = 5;
@@ -35,7 +35,7 @@ const chunkingHeader = { 'x-chunking-version': '2' };
  * uploading them in parallel, and emitting progress/error events.
  */
 export class ChunkedUploader {
-    constructor({ http, token, maxChunkConcurrency = defaultMaxChunkConcurrency, maxFinalizeMs, chunkByteCount = defaultChunkByteCount, logger = TurboWinstonLogger.default, chunkingMode = 'auto', dataItemByteCount, }) {
+    constructor({ http, token, maxChunkConcurrency = defaultMaxChunkConcurrency, maxFinalizeMs, chunkByteCount = defaultChunkByteCount, logger = Logger.default, chunkingMode = 'auto', dataItemByteCount, }) {
         this.assertChunkParams({
             chunkByteCount,
             chunkingMode,

package/lib/esm/common/factory.js

@@ -15,20 +15,16 @@
  */
 import { HexInjectedSolanaSigner, InjectedEthereumSigner, SignatureConfig, } from '@dha-team/arbundles';
 import { isEthereumWalletAdapter, isSolanaWalletAdapter, supportedEvmSignerTokens, } from '../types.js';
-import { TurboWinstonLogger } from './logger.js';
+import { Logger } from './logger.js';
 import { TurboAuthenticatedPaymentService, TurboUnauthenticatedPaymentService, } from './payment.js';
 import { defaultTokenMap } from './token/index.js';
 import { TurboAuthenticatedClient, TurboUnauthenticatedClient, } from './turbo.js';
 import { TurboUnauthenticatedUploadService } from './upload.js';
 export class TurboBaseFactory {
-    /* @deprecated - use TurboWinstonLogger directly */
+    /* @deprecated - use Logger directly */
     static setLogLevel(level) {
         this.logger.setLogLevel(level);
     }
-    /* @deprecated - use TurboWinstonLogger directly */
-    static setLogFormat(format) {
-        this.logger.setLogFormat(format);
-    }
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, token, } = {}) {
         token = token === 'pol' ? 'matic' : token;
         token ??= 'arweave'; // default to arweave if token is not provided
@@ -147,4 +143,4 @@ export class TurboBaseFactory {
         throw new Error('Unsupported wallet adapter -- wallet adapter is currently only supported for Solana and Ethereum');
     }
 }
-TurboBaseFactory.logger = TurboWinstonLogger.default;
+TurboBaseFactory.logger = Logger.default;

package/lib/esm/common/http.js

@@ -15,6 +15,7 @@
  */
 import { AxiosError, CanceledError } from 'axios';
 import { Readable } from 'node:stream';
+import { wrapFetchWithPayment } from 'x402-fetch';
 import { createAxiosInstance, defaultRetryConfig, } from '../utils/axiosClient.js';
 import { sleep } from '../utils/common.js';
 import { FailedRequestError } from '../utils/errors.js';
@@ -33,7 +34,46 @@ export class TurboHTTPService {
     async get({ endpoint, signal, allowedStatuses = [200, 202], headers, }) {
         return this.retryRequest(() => this.axios.get(endpoint, { headers, signal }), allowedStatuses);
     }
-    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, }) {
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, x402Options, }) {
+        if (x402Options !== undefined) {
+            this.logger.debug('Using X402 options for POST request', {
+                endpoint,
+                x402Options,
+            });
+            const { body, duplex } = await toX402FetchBody(data);
+            try {
+                const maxMUSDCAmount = x402Options.maxMUSDCAmount !== undefined
+                    ? BigInt(x402Options.maxMUSDCAmount.toString())
+                    : undefined;
+                const fetchWithPay = wrapFetchWithPayment(fetch, x402Options.signer, maxMUSDCAmount);
+                const res = await fetchWithPay(this.axios.defaults.baseURL + '/x402/data-item/signed', {
+                    method: 'POST',
+                    headers,
+                    body,
+                    signal,
+                    ...(duplex ? { duplex } : {}), // Use duplex only where streams are working
+                });
+                if (!allowedStatuses.includes(res.status)) {
+                    const errorText = await res.text();
+                    throw new FailedRequestError(
+                    // Return error message from server if available
+                    errorText || res.statusText, res.status);
+                }
+                return res.json();
+            }
+            catch (error) {
+                if (error instanceof FailedRequestError) {
+                    throw error; // rethrow FailedRequestError
+                }
+                // Handle CanceledError specifically
+                if (error.message.includes('The operation was aborted')) {
+                    throw new CanceledError();
+                }
+                // Log the error and throw a FailedRequestError
+                this.logger.error('Error posting data', { endpoint, error });
+                throw new FailedRequestError(error instanceof Error ? error.message : 'Unknown error', error.response?.status);
+            }
+        }
         // Buffer and Readable → keep Axios (streams work fine there)
         if (!(data instanceof ReadableStream)) {
             if (data instanceof Readable) {
@@ -137,3 +177,79 @@ async function toFetchBody(data) {
     const blob = await new Response(data).blob();
     return { body: blob }; // browser sets length
 }
+const isNode = typeof process !== 'undefined' && !!process.versions?.node;
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+function isFirefoxOrSafari() {
+    if (!isBrowser)
+        return false;
+    const ua = navigator.userAgent;
+    return ua.includes('Firefox') || ua.includes('Safari');
+}
+/** Create a re-usable body for x402 fetch protocol */
+export async function toX402FetchBody(data) {
+    //
+    // 🔹 NODE: always buffer to a non-stream body (Buffer)
+    //         so fetchWithPayment can reuse it safely.
+    //
+    if (isNode) {
+        let buf;
+        // Web ReadableStream → Buffer
+        if (typeof ReadableStream !== 'undefined' &&
+            data instanceof ReadableStream) {
+            const ab = await new Response(data).arrayBuffer();
+            buf = Buffer.from(ab);
+        }
+        // Node Readable → Buffer
+        else if (data instanceof Readable) {
+            const chunks = [];
+            for await (const chunk of data) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            buf = Buffer.concat(chunks.map((c) => Uint8Array.from(c)));
+        }
+        // Buffer / Uint8Array
+        else if (Buffer.isBuffer(data)) {
+            buf = data;
+        }
+        else if (data instanceof Uint8Array) {
+            buf = Buffer.from(data);
+        }
+        else {
+            throw new Error('Unsupported body type for toFetchBody (Node)');
+        }
+        // For Buffer body, Node *does not* need duplex.
+        return { body: buf };
+    }
+    //
+    // 🔹 BROWSER: keep your previous behavior (streams/Blob), no duplex.
+    //
+    let body;
+    // Already a web ReadableStream
+    if (typeof ReadableStream !== 'undefined' && data instanceof ReadableStream) {
+        body = data;
+    }
+    // Node Readable in browser (rare, but be safe) → Blob
+    else if (data instanceof Readable) {
+        const chunks = [];
+        for await (const chunk of data) {
+            const buf = typeof chunk === 'string'
+                ? new TextEncoder().encode(chunk)
+                : new Uint8Array(chunk);
+            chunks.push(buf);
+        }
+        body = new Blob(chunks);
+    }
+    // Buffer / Uint8Array
+    else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        body = new Blob([Uint8Array.from(data)]);
+    }
+    else {
+        throw new Error('Unsupported body type for toFetchBody (browser)');
+    }
+    // Firefox / Safari – avoid streaming uploads
+    if (isFirefoxOrSafari() && body instanceof ReadableStream) {
+        const blob = await new Response(body).blob();
+        return { body: blob };
+    }
+    return { body };
+}

package/lib/esm/common/logger.js

@@ -13,76 +13,67 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createLogger, format, transports, } from 'winston';
 import { version } from '../version.js';
-export class TurboWinstonLogger {
-    constructor({ level = 'info', logFormat = 'simple', } = {}) {
-        this.silent = false;
-        if (level === 'none') {
-            this.silent = true;
+export class Logger {
+    constructor({ level = 'info', } = {}) {
+        this.level = 'info';
+        this.levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3,
+            none: 999,
+        };
+        this.level = level;
+    }
+    formatMessage(level, message, ...args) {
+        const timestamp = new Date().toISOString();
+        const meta = {
+            timestamp,
+            level,
+            message,
+            name: 'turbo-sdk',
+            version,
+        };
+        if (args.length > 0) {
+            return JSON.stringify({ ...meta, args });
         }
-        if (typeof window !== 'undefined') {
-            this.logger = console;
+        return JSON.stringify(meta);
+    }
+    log(level, message, ...args) {
+        if (this.levels[level] < this.levels[this.level]) {
+            return;
         }
-        else {
-            this.logger = createLogger({
-                level,
-                silent: this.silent,
-                defaultMeta: {
-                    name: 'turbo-sdk',
-                    version,
-                },
-                format: format.combine(format.timestamp(), format.json()),
-                transports: [
-                    new transports.Console({
-                        format: getLogFormat(logFormat),
-                    }),
-                ],
-            });
+        const formattedMessage = this.formatMessage(level, message, ...args);
+        switch (level) {
+            case 'debug':
+                console.debug(formattedMessage);
+                break;
+            case 'info':
+                console.info(formattedMessage);
+                break;
+            case 'warn':
+                console.warn(formattedMessage);
+                break;
+            case 'error':
+                console.error(formattedMessage);
+                break;
         }
     }
     info(message, ...args) {
-        if (this.silent)
-            return;
-        this.logger.info(message, ...args);
+        this.log('info', message, ...args);
     }
     warn(message, ...args) {
-        if (this.silent)
-            return;
-        this.logger.warn(message, ...args);
+        this.log('warn', message, ...args);
     }
     error(message, ...args) {
-        if (this.silent)
-            return;
-        this.logger.error(message, ...args);
+        this.log('error', message, ...args);
     }
     debug(message, ...args) {
-        if (this.silent)
-            return;
-        this.logger.debug(message, ...args);
+        this.log('debug', message, ...args);
     }
     setLogLevel(level) {
-        this.silent = level === 'none';
-        if ('silent' in this.logger) {
-            this.logger.silent = level === 'none';
-        }
-        if ('level' in this.logger) {
-            this.logger.level = level;
-        }
-    }
-    setLogFormat(logFormat) {
-        if ('format' in this.logger) {
-            this.logger.format = getLogFormat(logFormat);
-        }
+        this.level = level;
     }
 }
-TurboWinstonLogger.default = new TurboWinstonLogger();
-function getLogFormat(logFormat) {
-    return format.combine(format((info) => {
-        if (info.stack && info.level !== 'error') {
-            delete info.stack;
-        }
-        return info;
-    })(), format.errors({ stack: true }), // Ensure errors show a stack trace
-    format.timestamp(), logFormat === 'json' ? format.json() : format.simple());
-}
+Logger.default = new Logger();

package/lib/esm/common/payment.js

@@ -17,12 +17,12 @@ import { BigNumber } from 'bignumber.js';
 import { defaultRetryConfig } from '../utils/axiosClient.js';
 import { isAnyValidUserAddress } from '../utils/common.js';
 import { TurboHTTPService } from './http.js';
-import { TurboWinstonLogger } from './logger.js';
+import { Logger } from './logger.js';
 import { exponentMap, tokenToBaseMap } from './token/index.js';
 export const developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 export const defaultPaymentServiceURL = 'https://payment.ardrive.io';
 export class TurboUnauthenticatedPaymentService {
-    constructor({ url = defaultPaymentServiceURL, logger = TurboWinstonLogger.default, retryConfig = defaultRetryConfig(logger), token = 'arweave', }) {
+    constructor({ url = defaultPaymentServiceURL, logger = Logger.default, retryConfig = defaultRetryConfig(logger), token = 'arweave', }) {
         this.logger = logger;
         this.httpService = new TurboHTTPService({
             url: `${url}/v1`,
@@ -241,7 +241,7 @@ export class TurboUnauthenticatedPaymentService {
 }
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
-    constructor({ url = defaultPaymentServiceURL, retryConfig, signer, logger = TurboWinstonLogger.default, token = 'arweave', tokenTools, }) {
+    constructor({ url = defaultPaymentServiceURL, retryConfig, signer, logger = Logger.default, token = 'arweave', tokenTools, }) {
         super({ url, retryConfig, logger, token });
         this.signer = signer;
         this.tokenTools = tokenTools;

package/lib/esm/common/signer.js

@@ -25,16 +25,19 @@ import { randomBytes } from 'crypto';
 import { Wallet as EthereumWallet, ethers, parseEther } from 'ethers';
 import { computeAddress } from 'ethers';
 import nacl from 'tweetnacl';
+import { createWalletClient, custom, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { baseSepolia } from 'viem/chains';
 import { isEthereumWalletAdapter, isSolanaWalletAdapter, } from '../types.js';
 import { fromB64Url, ownerToAddress as ownerToB64Address, toB64Url, } from '../utils/base64.js';
-import { TurboWinstonLogger } from './logger.js';
+import { Logger } from './logger.js';
 import { ethDataFromTurboCreditDestinationAddress } from './token/ethereum.js';
 import { memoProgramId } from './token/solana.js';
 /**
  * Abstract class for signing TurboDataItems.
  */
 export class TurboDataItemAbstractSigner {
-    constructor({ signer, logger = TurboWinstonLogger.default, token, walletAdapter, }) {
+    constructor({ signer, logger = Logger.default, token, walletAdapter, }) {
         this.logger = logger;
         this.signer = signer;
         this.token = token;
@@ -148,3 +151,34 @@ export class TurboDataItemAbstractSigner {
         return this.signer.sign(dataToSign);
     }
 }
+export async function makeX402Signer(arbundlesSigner) {
+    // Node: our SDK uses EthereumSigner with a raw private key
+    if (arbundlesSigner instanceof EthereumSigner) {
+        return createWalletClient({
+            account: privateKeyToAccount(('0x' +
+                Buffer.from(arbundlesSigner.key).toString('hex'))),
+            chain: baseSepolia,
+            transport: http(),
+        });
+    }
+    // Browser: use injected wallet + selected account
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof window !== 'undefined' && window.ethereum) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const provider = window.ethereum;
+        // ask wallet for an account
+        const accounts = (await provider.request({
+            method: 'eth_requestAccounts',
+        }));
+        if (accounts === undefined || accounts.length === 0) {
+            throw new Error('No accounts returned from wallet');
+        }
+        const account = accounts[0];
+        return createWalletClient({
+            account,
+            chain: baseSepolia,
+            transport: custom(provider),
+        });
+    }
+    throw new Error('Unable to construct x402 signer for x402 options');
+}

package/lib/esm/common/token/ario.js

@@ -18,9 +18,9 @@ import { connect, createDataItemSigner } from '@permaweb/aoconnect';
 import { BigNumber } from 'bignumber.js';
 import { defaultProdAoConfigs, sleep } from '../../utils/common.js';
 import { version } from '../../version.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 export class ARIOToken {
-    constructor({ cuUrl = defaultProdAoConfigs.ario.cuUrl, logger = TurboWinstonLogger.default, pollingOptions = {
+    constructor({ cuUrl = defaultProdAoConfigs.ario.cuUrl, logger = Logger.default, pollingOptions = {
         initialBackoffMs: 500,
         pollingIntervalMs: 0, // no polling for ARIO process
         maxAttempts: 0, // no polling for ARIO process

package/lib/esm/common/token/arweave.js

@@ -17,13 +17,13 @@ import ArweaveModule from 'arweave';
 import { BigNumber } from 'bignumber.js';
 import { sha256B64Url, toB64Url } from '../../utils/base64.js';
 import { sleep } from '../../utils/common.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 const ArweaveClass = 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore -- Access the correct class constructor for Arweave
 ArweaveModule.default?.default || ArweaveModule.default || ArweaveModule;
 export class ArweaveToken {
-    constructor({ gatewayUrl = 'https://arweave.net', arweave, logger = TurboWinstonLogger.default, mintU = true, pollingOptions = {
+    constructor({ gatewayUrl = 'https://arweave.net', arweave, logger = Logger.default, mintU = true, pollingOptions = {
         maxAttempts: 10,
         pollingIntervalMs: 3_000,
         initialBackoffMs: 7_000,

package/lib/esm/common/token/erc20.js

@@ -17,10 +17,10 @@ import { EthereumSigner } from '@dha-team/arbundles';
 import { Wallet as EthereumWallet, JsonRpcProvider, ethers } from 'ethers';
 import { isEthereumWalletAdapter, } from '../../types.js';
 import { defaultProdGatewayUrls } from '../../utils/common.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 import { EthereumToken, ethDataFromTurboCreditDestinationAddress, } from './ethereum.js';
 export class ERC20Token extends EthereumToken {
-    constructor({ tokenContractAddress, logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions, }) {
+    constructor({ tokenContractAddress, logger = Logger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions, }) {
         super({ logger, gatewayUrl, pollingOptions });
         this.tokenContract = new ethers.Contract(tokenContractAddress, [
             'function decimals() view returns (uint8)',

package/lib/esm/common/token/ethereum.js

@@ -16,7 +16,7 @@
 import { BigNumber } from 'bignumber.js';
 import { ethers, hexlify, toUtf8Bytes } from 'ethers';
 import { defaultProdGatewayUrls } from '../../utils/common.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 export const weiToTokenAmount = (wei) => wei;
 export const ETHToTokenAmount = (eth) => new BigNumber(eth).times(1e18).valueOf();
 export const defaultEthereumPollingOptions = {
@@ -25,7 +25,7 @@ export const defaultEthereumPollingOptions = {
     pollingIntervalMs: 1_500,
 };
 export class EthereumToken {
-    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions = defaultEthereumPollingOptions, } = {}) {
+    constructor({ logger = Logger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions = defaultEthereumPollingOptions, } = {}) {
         this.logger = logger;
         this.gatewayUrl = gatewayUrl;
         this.pollingOptions = pollingOptions;

package/lib/esm/common/token/kyve.js

@@ -23,14 +23,14 @@ import { BigNumber } from 'bignumber.js';
 import { createAxiosInstance } from '../../utils/axiosClient.js';
 import { defaultProdGatewayUrls } from '../../utils/common.js';
 import { sleep } from '../../utils/common.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 function hasKyveTxResponse(response) {
     return response.tx_response !== undefined;
 }
 export const ukyveToTokenAmount = (winston) => winston;
 export const KYVEToTokenAmount = (sol) => new BigNumber(sol).times(1e6).valueOf();
 export class KyveToken {
-    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.kyve, pollingOptions = {
+    constructor({ logger = Logger.default, gatewayUrl = defaultProdGatewayUrls.kyve, pollingOptions = {
         maxAttempts: 5,
         pollingIntervalMs: 1_000,
         initialBackoffMs: 500,

package/lib/esm/common/token/polygon.js

@@ -1,5 +1,5 @@
 import { defaultProdGatewayUrls } from '../../utils/common.js';
-import { TurboWinstonLogger } from '../logger.js';
+import { Logger } from '../logger.js';
 import { ETHToTokenAmount, EthereumToken } from './ethereum.js';
 export const POLToTokenAmount = ETHToTokenAmount;
 export const defaultPolygonPollingOptions = {
@@ -8,7 +8,7 @@ export const defaultPolygonPollingOptions = {
     pollingIntervalMs: 1_000,
 };
 export class PolygonToken extends EthereumToken {
-    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.pol, pollingOptions = defaultPolygonPollingOptions, } = {}) {
+    constructor({ logger = Logger.default, gatewayUrl = defaultProdGatewayUrls.pol, pollingOptions = defaultPolygonPollingOptions, } = {}) {
         super({ logger, gatewayUrl, pollingOptions });
     }
 }