@ardrive/turbo-sdk 1.4.2 → 1.5.0-alpha.1

package/lib/cjs/common/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./upload.js"), exports);
 __exportStar(require("./payment.js"), exports);
 __exportStar(require("./turbo.js"), exports);
 __exportStar(require("./currency.js"), exports);
+__exportStar(require("./token.js"), exports);

package/lib/cjs/common/payment.js

@@ -1,18 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurboAuthenticatedPaymentService = exports.TurboUnauthenticatedPaymentService = exports.defaultPaymentServiceURL = exports.developmentPaymentServiceURL = 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 bignumber_js_1 = require("bignumber.js");
 const http_js_1 = require("./http.js");
 const logger_js_1 = require("./logger.js");
+const token_js_1 = require("./token.js");
 exports.developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 exports.defaultPaymentServiceURL = 'https://payment.ardrive.io';
 class TurboUnauthenticatedPaymentService {
-    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, logger = new logger_js_1.TurboWinstonLogger(), }) {
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, logger = new logger_js_1.TurboWinstonLogger(), token = 'arweave', }) {
         this.logger = logger;
         this.httpService = new http_js_1.TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
             logger: this.logger,
         });
+        this.token = token;
     }
     getFiatRates() {
         return this.httpService.get({
@@ -73,13 +92,56 @@ class TurboUnauthenticatedPaymentService {
     createCheckoutSession(params) {
         return this.getCheckout(params);
     }
+    async submitFundTransaction({ txId, }) {
+        const response = await this.httpService.post({
+            endpoint: `/account/balance/${this.token}`,
+            data: Buffer.from(JSON.stringify({ tx_id: txId })),
+        });
+        if ('creditedTransaction' in response) {
+            return {
+                id: response.creditedTransaction.transactionId,
+                quantity: response.creditedTransaction.transactionQuantity,
+                owner: response.creditedTransaction.destinationAddress,
+                winc: response.creditedTransaction.winstonCreditAmount,
+                token: response.creditedTransaction.tokenType,
+                status: 'confirmed',
+                block: response.creditedTransaction.blockHeight,
+            };
+        }
+        else if ('pendingTransaction' in response) {
+            return {
+                id: response.pendingTransaction.transactionId,
+                quantity: response.pendingTransaction.transactionQuantity,
+                owner: response.pendingTransaction.destinationAddress,
+                winc: response.pendingTransaction.winstonCreditAmount,
+                token: response.pendingTransaction.tokenType,
+                status: 'pending',
+            };
+        }
+        else if ('failedTransaction' in response) {
+            return {
+                id: response.failedTransaction.transactionId,
+                quantity: response.failedTransaction.transactionQuantity,
+                owner: response.failedTransaction.destinationAddress,
+                winc: response.failedTransaction.winstonCreditAmount,
+                token: response.failedTransaction.tokenType,
+                status: 'failed',
+            };
+        }
+        throw new Error('Unknown response from payment service: ' + response);
+    }
 }
 exports.TurboUnauthenticatedPaymentService = TurboUnauthenticatedPaymentService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
 class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentService {
-    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, signer, logger, }) {
-        super({ url, retryConfig, logger });
+    constructor({ url = exports.defaultPaymentServiceURL, retryConfig, signer, logger = new logger_js_1.TurboWinstonLogger(), token = 'arweave', tokenMap = {
+        arweave: new token_js_1.ArweaveToken({
+            logger,
+        }),
+    }, }) {
+        super({ url, retryConfig, logger, token });
         this.signer = signer;
+        this.tokenMap = tokenMap;
     }
     async getBalance() {
         const headers = await this.signer.generateSignedRequestHeaders();
@@ -100,5 +162,44 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
     async createCheckoutSession(params) {
         return this.getCheckout(params, await this.signer.generateSignedRequestHeaders());
     }
+    async getTargetWalletForFund() {
+        const { addresses } = await this.httpService.get({
+            endpoint: '/info',
+        });
+        const walletAddress = addresses[this.token];
+        if (!walletAddress) {
+            throw new Error(`No wallet address found for token type: ${this.token}`);
+        }
+        return walletAddress;
+    }
+    async topUpWithTokens({ feeMultiplier = 1, tokenAmount: tokenAmountV, }) {
+        this.logger.debug('Funding account...');
+        const tokenAmount = new bignumber_js_1.BigNumber(tokenAmountV);
+        const target = await this.getTargetWalletForFund();
+        const fundTx = await this.tokenMap[this.token].createTx({
+            target,
+            tokenAmount,
+            feeMultiplier,
+        });
+        const signedTx = await this.tokenMap[this.token].signTx({
+            tx: fundTx,
+            signer: this.signer,
+        });
+        await this.tokenMap[this.token].submitTx({ tx: signedTx });
+        const txId = signedTx.id;
+        try {
+            // Let transaction settle some time
+            await this.tokenMap[this.token].pollForTxBeingAvailable({ txId });
+            return {
+                ...(await this.submitFundTransaction({ txId })),
+                target: signedTx.target,
+                reward: signedTx.reward,
+            };
+        }
+        catch (e) {
+            this.logger.error('Failed to submit fund transaction...', e);
+            throw Error(`Failed to submit fund transaction! Save this Transaction ID and try again with 'turbo.submitFundTransaction(id)': ${txId}`);
+        }
+    }
 }
 exports.TurboAuthenticatedPaymentService = TurboAuthenticatedPaymentService;

package/lib/cjs/common/signer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurboDataItemAbstractSigner = 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 crypto_1 = require("crypto");
+const base64_js_1 = require("../utils/base64.js");
+class TurboDataItemAbstractSigner {
+    constructor({ signer, logger }) {
+        this.logger = logger;
+        this.signer = signer;
+    }
+    async generateSignedRequestHeaders() {
+        const nonce = (0, crypto_1.randomBytes)(16).toString('hex');
+        const buffer = Buffer.from(nonce);
+        const signature = await this.signer.sign(buffer);
+        const publicKey = (0, base64_js_1.toB64Url)(this.signer.publicKey);
+        return {
+            'x-public-key': publicKey,
+            'x-nonce': nonce,
+            'x-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
+        };
+    }
+    async getPublicKey() {
+        return this.signer.publicKey;
+    }
+    async signData(dataToSign) {
+        return this.signer.sign(dataToSign);
+    }
+}
+exports.TurboDataItemAbstractSigner = TurboDataItemAbstractSigner;

package/lib/cjs/common/token.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARToTokenAmount = exports.WinstonToTokenAmount = exports.ArweaveToken = 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 arweave_1 = __importDefault(require("arweave"));
+const bignumber_js_1 = require("bignumber.js");
+const base64_js_1 = require("../utils/base64.js");
+const logger_js_1 = require("./logger.js");
+class ArweaveToken {
+    constructor({ arweave = arweave_1.default.init({
+        host: 'arweave.net',
+        port: 443,
+        protocol: 'https',
+    }), logger = new logger_js_1.TurboWinstonLogger(), mintU = true, pollingOptions = {
+        maxAttempts: 10,
+        pollingIntervalMs: 3000,
+        initialBackoffMs: 7000,
+    }, }) {
+        this.arweave = arweave;
+        this.logger = logger;
+        this.mintU = mintU;
+        this.pollingOptions = pollingOptions;
+    }
+    async createTx({ feeMultiplier, target, tokenAmount, }) {
+        const tx = await this.arweave.createTransaction({
+            target,
+            quantity: tokenAmount.toString(),
+            data: '',
+        });
+        if (feeMultiplier !== 1) {
+            tx.reward = (0, bignumber_js_1.BigNumber)(tx.reward)
+                .times((0, bignumber_js_1.BigNumber)(feeMultiplier))
+                .toFixed(0, bignumber_js_1.BigNumber.ROUND_UP);
+        }
+        if (this.mintU) {
+            tx.addTag('App-Name', 'SmartWeaveAction');
+            tx.addTag('App-Version', '0.3.0'); // cspell:disable
+            tx.addTag('Contract', 'KTzTXT_ANmF84fWEKHzWURD1LWd9QaFR9yfYUwH2Lxw'); // cspell:enable
+            tx.addTag('Input', JSON.stringify({ function: 'mint' }));
+        }
+        return tx;
+    }
+    async signTx({ tx, signer, }) {
+        const publicKeyB64Url = (0, base64_js_1.toB64Url)(await signer.getPublicKey());
+        tx.setOwner(publicKeyB64Url);
+        const dataToSign = await tx.getSignatureData();
+        const signatureBuffer = Buffer.from(await signer.signData(dataToSign));
+        const id = (0, base64_js_1.sha256B64Url)(signatureBuffer);
+        tx.setSignature({
+            id: id,
+            owner: publicKeyB64Url,
+            signature: (0, base64_js_1.toB64Url)(signatureBuffer),
+        });
+        return tx;
+    }
+    async pollForTxBeingAvailable({ txId, }) {
+        const { maxAttempts, pollingIntervalMs, initialBackoffMs } = this.pollingOptions;
+        await new Promise((resolve) => setTimeout(resolve, initialBackoffMs));
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const response = await this.arweave.api
+                .post('/graphql', {
+                query: `
+          query {
+            transaction(id: "${txId}") {
+              recipient
+              owner {
+                address
+              }
+              quantity {
+                winston
+              }
+            }
+          }
+        `,
+            })
+                .catch((err) => {
+                // Continue retries when request errors
+                this.logger.error('Failed to poll for transaction...', { err });
+                return undefined;
+            });
+            const transaction = response?.data?.data?.transaction;
+            if (transaction) {
+                return;
+            }
+            attempts++;
+            this.logger.debug('Transaction not found after polling...', {
+                txId,
+                attempts,
+            });
+            await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+        }
+        throw new Error('Transaction not found after polling, transaction id: ' + txId);
+    }
+    async submitTx({ tx }) {
+        const response = await this.arweave.transactions.post(tx).catch((err) => {
+            this.logger.error('Failed to post transaction...', { err });
+            return {
+                status: 500,
+                statusText: err instanceof Error ? err.message : 'Failed to post Arweave Tx!',
+            };
+        });
+        if (response.status !== 200) {
+            throw new Error('Failed to post transaction -- ' +
+                `Status ${response.status}, ${response.statusText}`);
+        }
+        this.logger.debug('Posted transaction...', { tx });
+    }
+}
+exports.ArweaveToken = ArweaveToken;
+const WinstonToTokenAmount = (winston) => winston;
+exports.WinstonToTokenAmount = WinstonToTokenAmount;
+const ARToTokenAmount = (ar) => new bignumber_js_1.BigNumber(ar).times(1e12).valueOf();
+exports.ARToTokenAmount = ARToTokenAmount;

package/lib/cjs/common/turbo.js

@@ -85,6 +85,12 @@ class TurboUnauthenticatedClient {
     createCheckoutSession(params) {
         return this.paymentService.createCheckoutSession(params);
     }
+    /**
+     * Submits a transaction ID to the Turbo Payment Service for processing.
+     */
+    submitFundTransaction(p) {
+        return this.paymentService.submitFundTransaction(p);
+    }
 }
 exports.TurboUnauthenticatedClient = TurboUnauthenticatedClient;
 class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
@@ -108,5 +114,12 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
             dataItemOpts,
         });
     }
+    /**
+     * Submits fund transaction to the token's blockchain then sends
+     * the transaction ID to the Turbo Payment Service for processing.
+     */
+    topUpWithTokens(p) {
+        return this.paymentService.topUpWithTokens(p);
+    }
 }
 exports.TurboAuthenticatedClient = TurboAuthenticatedClient;

package/lib/cjs/node/factory.js

@@ -22,7 +22,7 @@ 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, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
+    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, tokenMap, }) {
         let signer;
         if (providedSigner) {
             signer = providedSigner;
@@ -41,6 +41,7 @@ class TurboFactory extends factory_js_1.TurboBaseFactory {
             ...paymentServiceConfig,
             signer: turboSigner,
             logger: this.logger,
+            tokenMap,
         });
         const uploadService = new index_js_1.TurboAuthenticatedUploadService({
             ...uploadServiceConfig,

package/lib/cjs/node/signer.js

@@ -18,12 +18,11 @@ exports.TurboNodeArweaveSigner = void 0;
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 const arbundles_1 = require("arbundles");
-const node_crypto_1 = require("node:crypto");
+const signer_js_1 = require("../common/signer.js");
 const base64_js_1 = require("../utils/base64.js");
-class TurboNodeArweaveSigner {
-    constructor({ signer, logger, }) {
-        this.logger = logger;
-        this.signer = signer;
+class TurboNodeArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
+    constructor(p) {
+        super(p);
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, }) {
         // TODO: replace with our own signer implementation
@@ -41,18 +40,6 @@ class TurboNodeArweaveSigner {
             dataItemSizeFactory: () => signedDataItemSize,
         };
     }
-    // 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
-    async generateSignedRequestHeaders() {
-        const nonce = (0, node_crypto_1.randomBytes)(16).toString('hex');
-        const buffer = Buffer.from(nonce);
-        const signature = await this.signer.sign(buffer);
-        const publicKey = (0, base64_js_1.toB64Url)(this.signer.publicKey);
-        return {
-            'x-public-key': publicKey,
-            'x-nonce': nonce,
-            'x-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
-        };
-    }
     // TODO: make dynamic that accepts anchor and target and tags to return the size of the headers + data
     // reference https://github.com/ArweaveTeam/arweave-standards/blob/master/ans/ANS-104.md#13-dataitem-format
     calculateSignedDataHeadersSize({ dataSize, dataItemOpts, }) {

package/lib/cjs/types.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenTypes = void 0;
+exports.tokenTypes = ['arweave' /*'solana', 'ethereum'*/];

package/lib/cjs/version.js

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

package/lib/cjs/web/factory.js

@@ -22,7 +22,7 @@ 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, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, }) {
+    static authenticated({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, tokenMap, token, }) {
         let signer;
         if (providedSigner) {
             signer = providedSigner;
@@ -41,6 +41,8 @@ class TurboFactory extends factory_js_1.TurboBaseFactory {
             ...paymentServiceConfig,
             signer: turboSigner,
             logger: this.logger,
+            tokenMap,
+            token,
         });
         const uploadService = new index_js_1.TurboAuthenticatedUploadService({
             ...uploadServiceConfig,

package/lib/cjs/web/signer.js

@@ -18,25 +18,30 @@ exports.TurboWebArweaveSigner = void 0;
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 const arbundles_1 = require("arbundles");
-const crypto_1 = require("crypto");
-const base64_js_1 = require("../utils/base64.js");
+const signer_js_1 = require("../common/signer.js");
 const readableStream_js_1 = require("../utils/readableStream.js");
-class TurboWebArweaveSigner {
-    constructor({ logger, signer, }) {
-        this.logger = logger;
-        this.signer = signer;
+class TurboWebArweaveSigner extends signer_js_1.TurboDataItemAbstractSigner {
+    constructor(p) {
+        super(p);
+    }
+    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) {
+            await this.signer.setPublicKey();
+        }
+    }
+    async getPublicKey() {
+        await this.setPublicKey();
+        return super.getPublicKey();
     }
     async signDataItem({ fileStreamFactory, fileSizeFactory, dataItemOpts, }) {
+        await this.setPublicKey();
         // TODO: converts the readable stream to a buffer bc incrementally signing ReadableStreams is not trivial
         const buffer = await (0, readableStream_js_1.readableStreamToBuffer)({
             stream: fileStreamFactory(),
             size: fileSizeFactory(),
         });
-        // 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) {
-            await this.signer.setPublicKey();
-        }
         this.logger.debug('Signing data item...');
         const signedDataItem = (0, arbundles_1.createData)(buffer, this.signer, dataItemOpts);
         await signedDataItem.sign(this.signer);
@@ -47,22 +52,13 @@ class TurboWebArweaveSigner {
             dataItemSizeFactory: () => signedDataItem.getRaw().length,
         };
     }
-    // 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
     async generateSignedRequestHeaders() {
-        const nonce = (0, crypto_1.randomBytes)(16).toString('hex');
-        const buffer = Buffer.from(nonce);
-        const signature = await this.signer.sign(buffer);
-        // for arconnect, we need to make sure we have the public key
-        if (this.signer.publicKey === undefined &&
-            this.signer instanceof arbundles_1.ArconnectSigner) {
-            await this.signer.setPublicKey();
-        }
-        const publicKey = (0, base64_js_1.toB64Url)(this.signer.publicKey);
-        return {
-            'x-public-key': publicKey,
-            'x-nonce': nonce,
-            'x-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
-        };
+        await this.setPublicKey();
+        return super.generateSignedRequestHeaders();
+    }
+    async signData(dataToSign) {
+        await this.setPublicKey();
+        return super.signData(dataToSign);
     }
 }
 exports.TurboWebArweaveSigner = TurboWebArweaveSigner;

package/lib/esm/common/index.js

@@ -18,3 +18,4 @@ export * from './upload.js';
 export * from './payment.js';
 export * from './turbo.js';
 export * from './currency.js';
+export * from './token.js';

package/lib/esm/common/payment.js

@@ -1,15 +1,34 @@
+/**
+ * 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 { BigNumber } from 'bignumber.js';
 import { TurboHTTPService } from './http.js';
 import { TurboWinstonLogger } from './logger.js';
+import { ArweaveToken } from './token.js';
 export const developmentPaymentServiceURL = 'https://payment.ardrive.dev';
 export const defaultPaymentServiceURL = 'https://payment.ardrive.io';
 export class TurboUnauthenticatedPaymentService {
-    constructor({ url = defaultPaymentServiceURL, retryConfig, logger = new TurboWinstonLogger(), }) {
+    constructor({ url = defaultPaymentServiceURL, retryConfig, logger = new TurboWinstonLogger(), token = 'arweave', }) {
         this.logger = logger;
         this.httpService = new TurboHTTPService({
             url: `${url}/v1`,
             retryConfig,
             logger: this.logger,
         });
+        this.token = token;
     }
     getFiatRates() {
         return this.httpService.get({
@@ -70,12 +89,55 @@ export class TurboUnauthenticatedPaymentService {
     createCheckoutSession(params) {
         return this.getCheckout(params);
     }
+    async submitFundTransaction({ txId, }) {
+        const response = await this.httpService.post({
+            endpoint: `/account/balance/${this.token}`,
+            data: Buffer.from(JSON.stringify({ tx_id: txId })),
+        });
+        if ('creditedTransaction' in response) {
+            return {
+                id: response.creditedTransaction.transactionId,
+                quantity: response.creditedTransaction.transactionQuantity,
+                owner: response.creditedTransaction.destinationAddress,
+                winc: response.creditedTransaction.winstonCreditAmount,
+                token: response.creditedTransaction.tokenType,
+                status: 'confirmed',
+                block: response.creditedTransaction.blockHeight,
+            };
+        }
+        else if ('pendingTransaction' in response) {
+            return {
+                id: response.pendingTransaction.transactionId,
+                quantity: response.pendingTransaction.transactionQuantity,
+                owner: response.pendingTransaction.destinationAddress,
+                winc: response.pendingTransaction.winstonCreditAmount,
+                token: response.pendingTransaction.tokenType,
+                status: 'pending',
+            };
+        }
+        else if ('failedTransaction' in response) {
+            return {
+                id: response.failedTransaction.transactionId,
+                quantity: response.failedTransaction.transactionQuantity,
+                owner: response.failedTransaction.destinationAddress,
+                winc: response.failedTransaction.winstonCreditAmount,
+                token: response.failedTransaction.tokenType,
+                status: 'failed',
+            };
+        }
+        throw new Error('Unknown response from payment service: ' + response);
+    }
 }
 // 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, }) {
-        super({ url, retryConfig, logger });
+    constructor({ url = defaultPaymentServiceURL, retryConfig, signer, logger = new TurboWinstonLogger(), token = 'arweave', tokenMap = {
+        arweave: new ArweaveToken({
+            logger,
+        }),
+    }, }) {
+        super({ url, retryConfig, logger, token });
         this.signer = signer;
+        this.tokenMap = tokenMap;
     }
     async getBalance() {
         const headers = await this.signer.generateSignedRequestHeaders();
@@ -96,4 +158,43 @@ export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymen
     async createCheckoutSession(params) {
         return this.getCheckout(params, await this.signer.generateSignedRequestHeaders());
     }
+    async getTargetWalletForFund() {
+        const { addresses } = await this.httpService.get({
+            endpoint: '/info',
+        });
+        const walletAddress = addresses[this.token];
+        if (!walletAddress) {
+            throw new Error(`No wallet address found for token type: ${this.token}`);
+        }
+        return walletAddress;
+    }
+    async topUpWithTokens({ feeMultiplier = 1, tokenAmount: tokenAmountV, }) {
+        this.logger.debug('Funding account...');
+        const tokenAmount = new BigNumber(tokenAmountV);
+        const target = await this.getTargetWalletForFund();
+        const fundTx = await this.tokenMap[this.token].createTx({
+            target,
+            tokenAmount,
+            feeMultiplier,
+        });
+        const signedTx = await this.tokenMap[this.token].signTx({
+            tx: fundTx,
+            signer: this.signer,
+        });
+        await this.tokenMap[this.token].submitTx({ tx: signedTx });
+        const txId = signedTx.id;
+        try {
+            // Let transaction settle some time
+            await this.tokenMap[this.token].pollForTxBeingAvailable({ txId });
+            return {
+                ...(await this.submitFundTransaction({ txId })),
+                target: signedTx.target,
+                reward: signedTx.reward,
+            };
+        }
+        catch (e) {
+            this.logger.error('Failed to submit fund transaction...', e);
+            throw Error(`Failed to submit fund transaction! Save this Transaction ID and try again with 'turbo.submitFundTransaction(id)': ${txId}`);
+        }
+    }
 }