@ardrive/turbo-sdk 1.18.1-alpha.1 → 1.19.0

package/lib/cjs/common/factory.js

@@ -1,8 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboBaseFactory = 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 arbundles_1 = require("@dha-team/arbundles");
+const types_js_1 = require("../types.js");
 const logger_js_1 = require("./logger.js");
 const payment_js_1 = require("./payment.js");
+const index_js_1 = require("./token/index.js");
 const turbo_js_1 = require("./turbo.js");
 const upload_js_1 = require("./upload.js");
 class TurboBaseFactory {
@@ -16,6 +34,7 @@ class TurboBaseFactory {
     }
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, token, } = {}) {
         token = token === 'pol' ? 'matic' : token;
+        token ??= 'arweave'; // default to arweave if token is not provided
         const paymentService = new payment_js_1.TurboUnauthenticatedPaymentService({
             ...paymentServiceConfig,
             logger: this.logger,
@@ -31,6 +50,79 @@ class TurboBaseFactory {
             paymentService,
         });
     }
+    getAuthenticatedTurbo({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, logger, walletAdapter, }) {
+        token = token === 'pol' ? 'matic' : token;
+        if (!token) {
+            if (providedSigner) {
+                // Derive token from signer if not provided
+                if (providedSigner instanceof arbundles_1.EthereumSigner) {
+                    token = 'ethereum';
+                }
+                else if (providedSigner instanceof arbundles_1.HexSolanaSigner) {
+                    token = 'solana';
+                }
+                else {
+                    token = 'arweave';
+                }
+            }
+            else {
+                token = 'arweave';
+            }
+        }
+        token ??= 'arweave'; // default to arweave if token is not provided
+        if (walletAdapter) {
+            providedSigner = this.signerFromAdapter(walletAdapter, token);
+        }
+        const turboSigner = this.getSigner({
+            providedSigner,
+            providedPrivateKey: privateKey,
+            token,
+            logger,
+            providedWalletAdapter: walletAdapter,
+        });
+        if (!tokenTools) {
+            if (tokenMap && token === 'arweave') {
+                tokenTools = tokenMap.arweave;
+            }
+            tokenTools = index_js_1.defaultTokenMap[token]?.({
+                gatewayUrl,
+                logger,
+            });
+        }
+        const paymentService = new payment_js_1.TurboAuthenticatedPaymentService({
+            ...paymentServiceConfig,
+            signer: turboSigner,
+            logger,
+            token,
+            tokenTools,
+        });
+        const uploadService = this.getAuthenticatedUploadService({
+            ...uploadServiceConfig,
+            signer: turboSigner,
+            logger,
+            token,
+        });
+        return new turbo_js_1.TurboAuthenticatedClient({
+            uploadService,
+            paymentService,
+            signer: turboSigner,
+        });
+    }
+    signerFromAdapter(walletAdapter, token) {
+        if (token === 'solana') {
+            if (!(0, types_js_1.isSolanaWalletAdapter)(walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement publicKey and signMessage');
+            }
+            return new arbundles_1.HexInjectedSolanaSigner(walletAdapter);
+        }
+        if (token === 'ethereum') {
+            if (!(0, types_js_1.isEthereumWalletAdapter)(walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement getSigner');
+            }
+            return new arbundles_1.InjectedEthereumSigner(walletAdapter);
+        }
+        throw new Error('Unsupported wallet adapter -- wallet adapter is currently only supported for Solana and Ethereum');
+    }
 }
 exports.TurboBaseFactory = TurboBaseFactory;
 TurboBaseFactory.logger = logger_js_1.TurboWinstonLogger.default;

package/lib/cjs/common/signer.js

@@ -31,16 +31,18 @@ const ethers_1 = require("ethers");
 const ethers_2 = require("ethers");
 const node_buffer_1 = require("node:buffer");
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const types_js_1 = require("../types.js");
 const base64_js_1 = require("../utils/base64.js");
 const logger_js_1 = require("./logger.js");
 /**
  * Abstract class for signing TurboDataItems.
  */
 class TurboDataItemAbstractSigner {
-    constructor({ signer, logger = logger_js_1.TurboWinstonLogger.default, token, }) {
+    constructor({ signer, logger = logger_js_1.TurboWinstonLogger.default, token, walletAdapter, }) {
         this.logger = logger;
         this.signer = signer;
         this.token = token;
+        this.walletAdapter = walletAdapter;
     }
     ownerToNativeAddress(owner, token) {
         switch (token) {
@@ -79,6 +81,20 @@ class TurboDataItemAbstractSigner {
     }
     /** Let the signer handle sending tx for better compat with cross chain libraries/web wallets */
     async sendTransaction({ target, amount, gatewayUrl, }) {
+        if (this.walletAdapter) {
+            if (!(0, types_js_1.isEthereumWalletAdapter)(this.walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement getSigner');
+            }
+            const signer = this.walletAdapter.getSigner();
+            if (signer.sendTransaction === undefined) {
+                throw new Error('Unsupported wallet adapter -- getSigner must return a signer with sendTransaction API for crypto funds transfer');
+            }
+            const { hash } = await signer.sendTransaction({
+                to: target,
+                value: (0, ethers_1.parseEther)(amount.toFixed(18)),
+            });
+            return hash;
+        }
         if (!(this.signer instanceof arbundles_1.EthereumSigner)) {
             throw new Error('Only EthereumSigner is supported for sendTransaction API currently!');
         }
@@ -95,7 +111,6 @@ class TurboDataItemAbstractSigner {
             await tx.execute();
             return tx.txHash;
         }
-        // TODO: ETH Web wallet tx signing/sending
         const provider = new ethers_1.ethers.JsonRpcProvider(gatewayUrl);
         const ethWalletAndProvider = new ethers_1.Wallet(keyAsStringFromUint8Array, provider);
         const tx = await ethWalletAndProvider.sendTransaction({

package/lib/cjs/common/token/solana.js

@@ -32,8 +32,8 @@ exports.SOLToTokenAmount = SOLToTokenAmount;
 class SolanaToken {
     constructor({ logger = logger_js_1.TurboWinstonLogger.default, gatewayUrl = 'https://api.mainnet-beta.solana.com', pollingOptions = {
         maxAttempts: 10,
-        pollingIntervalMs: 5_000,
-        initialBackoffMs: 7_000,
+        pollingIntervalMs: 2_500,
+        initialBackoffMs: 500,
     }, } = {}) {
         this.logger = logger;
         this.gatewayUrl = gatewayUrl;

package/lib/cjs/node/factory.js

@@ -16,72 +16,39 @@ exports.TurboFactory = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const arbundles_1 = require("@dha-team/arbundles");
 const factory_js_1 = require("../common/factory.js");
-const index_js_1 = require("../common/index.js");
-const payment_js_1 = require("../common/payment.js");
-const turbo_js_1 = require("../common/turbo.js");
 const common_js_1 = require("../utils/common.js");
 const signer_js_1 = require("./signer.js");
 const upload_js_1 = require("./upload.js");
 class TurboFactory extends factory_js_1.TurboBaseFactory {
-    static getSigner(providedSigner, providedPrivateKey, token) {
+    getSigner({ logger, providedPrivateKey, providedSigner, providedWalletAdapter, token, }) {
         return new signer_js_1.TurboNodeSigner({
             signer: (0, common_js_1.createTurboSigner)({
                 signer: providedSigner,
                 privateKey: providedPrivateKey,
                 token,
             }),
-            logger: this.logger,
+            logger,
             token,
+            walletAdapter: providedWalletAdapter,
         });
     }
-    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, tokenMap, gatewayUrl, tokenTools, }) {
-        token = token === 'pol' ? 'matic' : token;
-        if (!token) {
-            if (providedSigner) {
-                // Derive token from signer if not provided
-                if (providedSigner instanceof arbundles_1.EthereumSigner) {
-                    token = 'ethereum';
-                }
-                else if (providedSigner instanceof arbundles_1.HexSolanaSigner) {
-                    token = 'solana';
-                }
-                else {
-                    token = 'arweave';
-                }
-            }
-            else {
-                token = 'arweave';
-            }
-        }
-        const turboSigner = this.getSigner(providedSigner, privateKey, token);
-        if (!tokenTools) {
-            if (tokenMap && token === 'arweave') {
-                tokenTools = tokenMap.arweave;
-            }
-            tokenTools = index_js_1.defaultTokenMap[token]?.({
-                gatewayUrl,
-                logger: this.logger,
-            });
-        }
-        const paymentService = new payment_js_1.TurboAuthenticatedPaymentService({
-            ...paymentServiceConfig,
-            signer: turboSigner,
-            logger: this.logger,
+    getAuthenticatedUploadService(config) {
+        // Import the TurboAuthenticatedUploadService class from the node upload module
+        return new upload_js_1.TurboAuthenticatedUploadService(config);
+    }
+    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, tokenMap, gatewayUrl, tokenTools, walletAdapter, }) {
+        return new TurboFactory().getAuthenticatedTurbo({
+            privateKey,
+            signer: providedSigner,
+            paymentServiceConfig,
+            uploadServiceConfig,
             token,
+            tokenMap,
+            gatewayUrl,
             tokenTools,
-        });
-        const uploadService = new upload_js_1.TurboAuthenticatedUploadService({
-            ...uploadServiceConfig,
-            signer: turboSigner,
+            walletAdapter,
             logger: this.logger,
-            token,
-        });
-        return new turbo_js_1.TurboAuthenticatedClient({
-            uploadService,
-            paymentService,
-            signer: turboSigner,
         });
     }
 }

package/lib/cjs/types.js

@@ -4,6 +4,8 @@ exports.isJWK = exports.isWebUploadFolderParams = exports.isNodeUploadFolderPara
 exports.isCurrency = isCurrency;
 exports.isKyvePrivateKey = isKyvePrivateKey;
 exports.isEthPrivateKey = isEthPrivateKey;
+exports.isSolanaWalletAdapter = isSolanaWalletAdapter;
+exports.isEthereumWalletAdapter = isEthereumWalletAdapter;
 exports.fiatCurrencyTypes = [
     'usd',
     'eur',
@@ -44,3 +46,9 @@ function isEthPrivateKey(wallet) {
 }
 const isJWK = (wallet) => wallet.kty !== undefined;
 exports.isJWK = isJWK;
+function isSolanaWalletAdapter(walletAdapter) {
+    return 'publicKey' in walletAdapter && 'signMessage' in walletAdapter;
+}
+function isEthereumWalletAdapter(walletAdapter) {
+    return 'getSigner' in walletAdapter;
+}

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.18.1-alpha.1';
+exports.version = '1.19.0';

package/lib/cjs/web/factory.js

@@ -16,71 +16,39 @@ exports.TurboFactory = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const arbundles_1 = require("@dha-team/arbundles");
 const factory_js_1 = require("../common/factory.js");
-const index_js_1 = require("../common/index.js");
 const common_js_1 = require("../utils/common.js");
 const signer_js_1 = require("./signer.js");
 const upload_js_1 = require("./upload.js");
 class TurboFactory extends factory_js_1.TurboBaseFactory {
-    static getSigner(providedSigner, providedPrivateKey, token) {
+    getSigner({ providedPrivateKey, logger, providedSigner, providedWalletAdapter, token, }) {
         return new signer_js_1.TurboWebArweaveSigner({
             signer: (0, common_js_1.createTurboSigner)({
                 signer: providedSigner,
                 privateKey: providedPrivateKey,
                 token,
             }),
-            logger: this.logger,
+            logger: logger,
             token,
+            walletAdapter: providedWalletAdapter,
         });
     }
-    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, }) {
-        token = token === 'pol' ? 'matic' : token;
-        if (!token) {
-            if (providedSigner) {
-                // Derive token from signer if not provided
-                if (providedSigner instanceof arbundles_1.EthereumSigner) {
-                    token = 'ethereum';
-                }
-                else if (providedSigner instanceof arbundles_1.HexSolanaSigner) {
-                    token = 'solana';
-                }
-                else {
-                    token = 'arweave';
-                }
-            }
-            else {
-                token = 'arweave';
-            }
-        }
-        const turboSigner = this.getSigner(providedSigner, privateKey, token);
-        token ??= 'arweave'; // default to arweave if token is not provided
-        if (!tokenTools) {
-            if (tokenMap && token === 'arweave') {
-                tokenTools = tokenMap.arweave;
-            }
-            tokenTools = index_js_1.defaultTokenMap[token]?.({
-                gatewayUrl,
-                logger: this.logger,
-            });
-        }
-        const paymentService = new index_js_1.TurboAuthenticatedPaymentService({
-            ...paymentServiceConfig,
-            signer: turboSigner,
-            logger: this.logger,
+    getAuthenticatedUploadService(config) {
+        // Import the TurboAuthenticatedUploadService class from the web upload module
+        return new upload_js_1.TurboAuthenticatedUploadService(config);
+    }
+    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, walletAdapter, }) {
+        return new TurboFactory().getAuthenticatedTurbo({
+            privateKey,
+            signer: providedSigner,
+            paymentServiceConfig,
+            uploadServiceConfig,
             token,
+            gatewayUrl,
+            tokenMap,
             tokenTools,
-        });
-        const uploadService = new upload_js_1.TurboAuthenticatedUploadService({
-            ...uploadServiceConfig,
-            signer: turboSigner,
             logger: this.logger,
-            token,
-        });
-        return new index_js_1.TurboAuthenticatedClient({
-            uploadService,
-            paymentService,
-            signer: turboSigner,
+            walletAdapter,
         });
     }
 }

package/lib/cjs/web/signer.js

@@ -21,6 +21,7 @@ Object.defineProperty(exports, "ArconnectSigner", { enumerable: true, get: funct
 Object.defineProperty(exports, "ArweaveSigner", { enumerable: true, get: function () { return arbundles_1.ArweaveSigner; } });
 Object.defineProperty(exports, "EthereumSigner", { enumerable: true, get: function () { return arbundles_1.EthereumSigner; } });
 Object.defineProperty(exports, "HexSolanaSigner", { enumerable: true, get: function () { return arbundles_1.HexSolanaSigner; } });
+const node_buffer_1 = require("node:buffer");
 const signer_js_1 = require("../common/signer.js");
 const readableStream_js_1 = require("../utils/readableStream.js");
 /**
@@ -33,7 +34,8 @@ class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
     async setPublicKey() {
         // for arconnect, we need to make sure we have the public key before create data
         if (this.signer.publicKey === undefined &&
-            this.signer instanceof arbundles_1.ArconnectSigner) {
+            (this.signer instanceof arbundles_1.ArconnectSigner ||
+                this.signer instanceof arbundles_1.InjectedEthereumSigner)) {
             await this.signer.setPublicKey();
         }
     }
@@ -45,7 +47,7 @@ class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
         await this.setPublicKey();
         const fileStream = fileStreamFactory();
         // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
-        const buffer = fileStream instanceof Buffer
+        const buffer = fileStream instanceof node_buffer_1.Buffer
             ? fileStream
             : await (0, readableStream_js_1.readableStreamToBuffer)({
                 stream: fileStream,

package/lib/esm/common/factory.js

@@ -1,6 +1,24 @@
+/**
+ * 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.
+ */
+import { EthereumSigner, HexInjectedSolanaSigner, HexSolanaSigner, InjectedEthereumSigner, } from '@dha-team/arbundles';
+import { isEthereumWalletAdapter, isSolanaWalletAdapter, } from '../types.js';
 import { TurboWinstonLogger } from './logger.js';
-import { TurboUnauthenticatedPaymentService } from './payment.js';
-import { TurboUnauthenticatedClient } from './turbo.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 */
@@ -13,6 +31,7 @@ export class TurboBaseFactory {
     }
     static unauthenticated({ paymentServiceConfig = {}, uploadServiceConfig = {}, token, } = {}) {
         token = token === 'pol' ? 'matic' : token;
+        token ??= 'arweave'; // default to arweave if token is not provided
         const paymentService = new TurboUnauthenticatedPaymentService({
             ...paymentServiceConfig,
             logger: this.logger,
@@ -28,5 +47,78 @@ export class TurboBaseFactory {
             paymentService,
         });
     }
+    getAuthenticatedTurbo({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, logger, walletAdapter, }) {
+        token = token === 'pol' ? 'matic' : token;
+        if (!token) {
+            if (providedSigner) {
+                // Derive token from signer if not provided
+                if (providedSigner instanceof EthereumSigner) {
+                    token = 'ethereum';
+                }
+                else if (providedSigner instanceof HexSolanaSigner) {
+                    token = 'solana';
+                }
+                else {
+                    token = 'arweave';
+                }
+            }
+            else {
+                token = 'arweave';
+            }
+        }
+        token ??= 'arweave'; // default to arweave if token is not provided
+        if (walletAdapter) {
+            providedSigner = this.signerFromAdapter(walletAdapter, token);
+        }
+        const turboSigner = this.getSigner({
+            providedSigner,
+            providedPrivateKey: privateKey,
+            token,
+            logger,
+            providedWalletAdapter: walletAdapter,
+        });
+        if (!tokenTools) {
+            if (tokenMap && token === 'arweave') {
+                tokenTools = tokenMap.arweave;
+            }
+            tokenTools = defaultTokenMap[token]?.({
+                gatewayUrl,
+                logger,
+            });
+        }
+        const paymentService = new TurboAuthenticatedPaymentService({
+            ...paymentServiceConfig,
+            signer: turboSigner,
+            logger,
+            token,
+            tokenTools,
+        });
+        const uploadService = this.getAuthenticatedUploadService({
+            ...uploadServiceConfig,
+            signer: turboSigner,
+            logger,
+            token,
+        });
+        return new TurboAuthenticatedClient({
+            uploadService,
+            paymentService,
+            signer: turboSigner,
+        });
+    }
+    signerFromAdapter(walletAdapter, token) {
+        if (token === 'solana') {
+            if (!isSolanaWalletAdapter(walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement publicKey and signMessage');
+            }
+            return new HexInjectedSolanaSigner(walletAdapter);
+        }
+        if (token === 'ethereum') {
+            if (!isEthereumWalletAdapter(walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement getSigner');
+            }
+            return new InjectedEthereumSigner(walletAdapter);
+        }
+        throw new Error('Unsupported wallet adapter -- wallet adapter is currently only supported for Solana and Ethereum');
+    }
 }
 TurboBaseFactory.logger = TurboWinstonLogger.default;

package/lib/esm/common/signer.js

@@ -25,16 +25,18 @@ import { Wallet as EthereumWallet, ethers, parseEther } from 'ethers';
 import { computeAddress } from 'ethers';
 import { Buffer } from 'node:buffer';
 import nacl from 'tweetnacl';
+import { isEthereumWalletAdapter, } from '../types.js';
 import { fromB64Url, ownerToAddress as ownerToB64Address, toB64Url, } from '../utils/base64.js';
 import { TurboWinstonLogger } from './logger.js';
 /**
  * Abstract class for signing TurboDataItems.
  */
 export class TurboDataItemAbstractSigner {
-    constructor({ signer, logger = TurboWinstonLogger.default, token, }) {
+    constructor({ signer, logger = TurboWinstonLogger.default, token, walletAdapter, }) {
         this.logger = logger;
         this.signer = signer;
         this.token = token;
+        this.walletAdapter = walletAdapter;
     }
     ownerToNativeAddress(owner, token) {
         switch (token) {
@@ -73,6 +75,20 @@ export class TurboDataItemAbstractSigner {
     }
     /** Let the signer handle sending tx for better compat with cross chain libraries/web wallets */
     async sendTransaction({ target, amount, gatewayUrl, }) {
+        if (this.walletAdapter) {
+            if (!isEthereumWalletAdapter(this.walletAdapter)) {
+                throw new Error('Unsupported wallet adapter -- must implement getSigner');
+            }
+            const signer = this.walletAdapter.getSigner();
+            if (signer.sendTransaction === undefined) {
+                throw new Error('Unsupported wallet adapter -- getSigner must return a signer with sendTransaction API for crypto funds transfer');
+            }
+            const { hash } = await signer.sendTransaction({
+                to: target,
+                value: parseEther(amount.toFixed(18)),
+            });
+            return hash;
+        }
         if (!(this.signer instanceof EthereumSigner)) {
             throw new Error('Only EthereumSigner is supported for sendTransaction API currently!');
         }
@@ -89,7 +105,6 @@ export class TurboDataItemAbstractSigner {
             await tx.execute();
             return tx.txHash;
         }
-        // TODO: ETH Web wallet tx signing/sending
         const provider = new ethers.JsonRpcProvider(gatewayUrl);
         const ethWalletAndProvider = new EthereumWallet(keyAsStringFromUint8Array, provider);
         const tx = await ethWalletAndProvider.sendTransaction({

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

@@ -24,8 +24,8 @@ export const SOLToTokenAmount = (sol) => new BigNumber(sol).times(1e9).valueOf()
 export class SolanaToken {
     constructor({ logger = TurboWinstonLogger.default, gatewayUrl = 'https://api.mainnet-beta.solana.com', pollingOptions = {
         maxAttempts: 10,
-        pollingIntervalMs: 5_000,
-        initialBackoffMs: 7_000,
+        pollingIntervalMs: 2_500,
+        initialBackoffMs: 500,
     }, } = {}) {
         this.logger = logger;
         this.gatewayUrl = gatewayUrl;

package/lib/esm/node/factory.js

@@ -13,72 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EthereumSigner, HexSolanaSigner } from '@dha-team/arbundles';
 import { TurboBaseFactory } from '../common/factory.js';
-import { defaultTokenMap } from '../common/index.js';
-import { TurboAuthenticatedPaymentService } from '../common/payment.js';
-import { TurboAuthenticatedClient } from '../common/turbo.js';
 import { createTurboSigner } from '../utils/common.js';
 import { TurboNodeSigner } from './signer.js';
 import { TurboAuthenticatedUploadService } from './upload.js';
 export class TurboFactory extends TurboBaseFactory {
-    static getSigner(providedSigner, providedPrivateKey, token) {
+    getSigner({ logger, providedPrivateKey, providedSigner, providedWalletAdapter, token, }) {
         return new TurboNodeSigner({
             signer: createTurboSigner({
                 signer: providedSigner,
                 privateKey: providedPrivateKey,
                 token,
             }),
-            logger: this.logger,
+            logger,
             token,
+            walletAdapter: providedWalletAdapter,
         });
     }
-    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, tokenMap, gatewayUrl, tokenTools, }) {
-        token = token === 'pol' ? 'matic' : token;
-        if (!token) {
-            if (providedSigner) {
-                // Derive token from signer if not provided
-                if (providedSigner instanceof EthereumSigner) {
-                    token = 'ethereum';
-                }
-                else if (providedSigner instanceof HexSolanaSigner) {
-                    token = 'solana';
-                }
-                else {
-                    token = 'arweave';
-                }
-            }
-            else {
-                token = 'arweave';
-            }
-        }
-        const turboSigner = this.getSigner(providedSigner, privateKey, token);
-        if (!tokenTools) {
-            if (tokenMap && token === 'arweave') {
-                tokenTools = tokenMap.arweave;
-            }
-            tokenTools = defaultTokenMap[token]?.({
-                gatewayUrl,
-                logger: this.logger,
-            });
-        }
-        const paymentService = new TurboAuthenticatedPaymentService({
-            ...paymentServiceConfig,
-            signer: turboSigner,
-            logger: this.logger,
+    getAuthenticatedUploadService(config) {
+        // Import the TurboAuthenticatedUploadService class from the node upload module
+        return new TurboAuthenticatedUploadService(config);
+    }
+    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, tokenMap, gatewayUrl, tokenTools, walletAdapter, }) {
+        return new TurboFactory().getAuthenticatedTurbo({
+            privateKey,
+            signer: providedSigner,
+            paymentServiceConfig,
+            uploadServiceConfig,
             token,
+            tokenMap,
+            gatewayUrl,
             tokenTools,
-        });
-        const uploadService = new TurboAuthenticatedUploadService({
-            ...uploadServiceConfig,
-            signer: turboSigner,
+            walletAdapter,
             logger: this.logger,
-            token,
-        });
-        return new TurboAuthenticatedClient({
-            uploadService,
-            paymentService,
-            signer: turboSigner,
         });
     }
 }