@ardrive/turbo-sdk 1.19.2 → 1.20.0-alpha.1

package/lib/cjs/cli/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.turboCliTags = void 0;
+exports.wincPerCredit = exports.turboCliTags = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -22,3 +22,4 @@ exports.turboCliTags = [
     { name: 'App-Version', value: version_js_1.version },
     { name: 'App-Platform', value: process.platform },
 ];
+exports.wincPerCredit = 1_000_000_000_000;

package/lib/cjs/cli/options.js

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadFileOptions = exports.uploadFolderOptions = exports.globalOptions = exports.walletOptions = exports.optionMap = void 0;
+exports.listApprovalsOptions = exports.revokeApprovalsOptions = exports.createApprovalOptions = exports.uploadFileOptions = exports.uploadFolderOptions = exports.uploadOptions = exports.globalOptions = exports.walletOptions = exports.optionMap = void 0;
 exports.optionMap = {
     token: {
         alias: '-t, --token <type>',
@@ -73,7 +73,12 @@ exports.optionMap = {
     },
     dev: {
         alias: '--dev',
-        description: 'Enable development endpoints',
+        description: 'Enable Turbo development endpoints',
+        default: false,
+    },
+    local: {
+        alias: '--local',
+        description: 'Enable local development endpoints',
         default: false,
     },
     debug: {
@@ -118,6 +123,25 @@ exports.optionMap = {
         alias: '--max-concurrency <maxConcurrency>',
         description: 'Maximum number of concurrent uploads',
     },
+    paidBy: {
+        alias: '--paid-by <paidBy...>',
+        description: 'Address to pay for the upload',
+        type: 'array',
+    },
+    expiresBySeconds: {
+        alias: '--expires-by-seconds <expiresBySeconds>',
+        description: 'Expiration time in seconds',
+    },
+    ignoreApprovals: {
+        alias: '--ignore-approvals',
+        description: "Ignore all delegated payment approvals, only use signing wallet's balance",
+        default: false,
+    },
+    useSignerBalanceFirst: {
+        alias: '--use-signer-balance-first',
+        description: 'Use the signer balance first before using delegated payment approvals',
+        default: false,
+    },
 };
 exports.walletOptions = [
     exports.optionMap.walletFile,
@@ -126,6 +150,7 @@ exports.walletOptions = [
 ];
 exports.globalOptions = [
     exports.optionMap.dev,
+    exports.optionMap.local,
     exports.optionMap.gateway,
     exports.optionMap.debug,
     exports.optionMap.quiet,
@@ -134,12 +159,26 @@ exports.globalOptions = [
     exports.optionMap.paymentUrl,
     exports.optionMap.uploadUrl,
 ];
-exports.uploadFolderOptions = [
+exports.uploadOptions = [
     ...exports.walletOptions,
+    exports.optionMap.paidBy,
+    exports.optionMap.ignoreApprovals,
+    exports.optionMap.useSignerBalanceFirst,
+];
+exports.uploadFolderOptions = [
+    ...exports.uploadOptions,
     exports.optionMap.folderPath,
     exports.optionMap.indexFile,
     exports.optionMap.fallbackFile,
     exports.optionMap.manifest,
     exports.optionMap.maxConcurrency,
 ];
-exports.uploadFileOptions = [...exports.walletOptions, exports.optionMap.filePath];
+exports.uploadFileOptions = [...exports.uploadOptions, exports.optionMap.filePath];
+exports.createApprovalOptions = [
+    ...exports.walletOptions,
+    exports.optionMap.value,
+    exports.optionMap.address,
+    exports.optionMap.expiresBySeconds,
+];
+exports.revokeApprovalsOptions = [...exports.walletOptions, exports.optionMap.address];
+exports.listApprovalsOptions = exports.revokeApprovalsOptions;

package/lib/cjs/cli/utils.js

@@ -14,6 +14,7 @@ exports.optionalPrivateKeyFromOptions = optionalPrivateKeyFromOptions;
 exports.privateKeyFromOptions = privateKeyFromOptions;
 exports.configFromOptions = configFromOptions;
 exports.turboFromOptions = turboFromOptions;
+exports.paidByFromOptions = paidByFromOptions;
 exports.getUploadFolderOptions = getUploadFolderOptions;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
@@ -138,12 +139,21 @@ function configFromOptions(options) {
     let paymentUrl = undefined;
     let uploadUrl = undefined;
     let gatewayUrl = undefined;
+    if (options.local && options.dev) {
+        throw new Error('Cannot use both --local and --dev flags');
+    }
     if (options.dev) {
         // Use development endpoints
         paymentUrl = index_js_1.developmentTurboConfiguration.paymentServiceConfig.url;
         uploadUrl = index_js_1.developmentTurboConfiguration.uploadServiceConfig.url;
         gatewayUrl = tokenToDevGatewayMap[token];
     }
+    else if (options.local) {
+        // Use local endpoints
+        paymentUrl = 'http://localhost:4000';
+        uploadUrl = 'http://localhost:3000';
+        gatewayUrl = 'http://localhost:1984';
+    }
     else {
         // Use default endpoints
         paymentUrl = index_js_1.defaultTurboConfiguration.paymentServiceConfig.url;
@@ -174,6 +184,27 @@ async function turboFromOptions(options) {
         privateKey,
     });
 }
+async function paidByFromOptions({ paidBy: paidByCliInput, ignoreApprovals, useSignerBalanceFirst, }, turbo) {
+    const paidBy = await (async () => {
+        if (paidByCliInput !== undefined && paidByCliInput.length > 0) {
+            return paidByCliInput;
+        }
+        if (ignoreApprovals) {
+            return undefined;
+        }
+        const { receivedApprovals } = await turbo.getBalance();
+        if (receivedApprovals !== undefined && receivedApprovals.length !== 0) {
+            // get unique paying addresses from any received approvals
+            return Array.from(new Set(receivedApprovals.map((approval) => approval.payingAddress)));
+        }
+        return undefined;
+    })();
+    if (paidBy !== undefined && useSignerBalanceFirst) {
+        // Add the signer's address to the front of the paidBy array
+        paidBy.unshift(await turbo.signer.getNativeAddress());
+    }
+    return paidBy;
+}
 function getUploadFolderOptions(options) {
     if (options.folderPath === undefined) {
         throw new Error('--folder-path is required');

package/lib/cjs/common/payment.js

@@ -37,7 +37,15 @@ class TurboUnauthenticatedPaymentService {
             endpoint: `/account/balance/${this.token}?address=${address}`,
             allowedStatuses: [200, 404],
         });
-        return balance.winc ? balance : { winc: '0' };
+        return balance.winc
+            ? balance
+            : {
+                winc: '0',
+                controlledWinc: '0',
+                effectiveBalance: '0',
+                givenApprovals: [],
+                receivedApprovals: [],
+            };
     }
     getFiatRates() {
         return this.httpService.get({
@@ -156,6 +164,20 @@ class TurboUnauthenticatedPaymentService {
         }
         throw new Error('Unknown response from payment service: ' + response);
     }
+    async getDelegatedPaymentApprovals({ userAddress, }) {
+        const response = await this.httpService.get({
+            endpoint: `/account/approvals/get?userAddress=${userAddress}`,
+            allowedStatuses: [200, 404],
+        });
+        if (response?.givenApprovals === undefined &&
+            response?.receivedApprovals === undefined) {
+            return {
+                givenApprovals: [],
+                receivedApprovals: [],
+            };
+        }
+        return response;
+    }
 }
 exports.TurboUnauthenticatedPaymentService = TurboUnauthenticatedPaymentService;
 // NOTE: to avoid redundancy, we use inheritance here - but generally prefer composition over inheritance
@@ -165,9 +187,13 @@ class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymentServic
         this.signer = signer;
         this.tokenTools = tokenTools;
     }
-    async getBalance(address) {
-        address ??= await this.signer.getNativeAddress();
-        return super.getBalance(address);
+    async getBalance(userAddress) {
+        userAddress ??= await this.signer.getNativeAddress();
+        return super.getBalance(userAddress);
+    }
+    async getDelegatedPaymentApprovals({ userAddress, }) {
+        userAddress ??= await this.signer.getNativeAddress();
+        return super.getDelegatedPaymentApprovals({ userAddress });
     }
     async getWincForFiat({ amount, promoCodes = [], }) {
         return super.getWincForFiat({

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

@@ -41,7 +41,7 @@ class SolanaToken {
         this.pollingOptions = pollingOptions;
     }
     async createAndSubmitTx({ target, tokenAmount, signer, }) {
-        const publicKey = new web3_js_1.PublicKey(bs58_1.default.encode(await signer.getPublicKey()));
+        const publicKey = new web3_js_1.PublicKey(bs58_1.default.encode(Uint8Array.from(await signer.getPublicKey())));
         const tx = new web3_js_1.Transaction({
             feePayer: publicKey,
             ...(await this.connection.getLatestBlockhash()),
@@ -52,7 +52,7 @@ class SolanaToken {
             lamports: +new bignumber_js_1.BigNumber(tokenAmount),
         }));
         const serializedTx = tx.serializeMessage();
-        const signature = await signer.signData(serializedTx);
+        const signature = await signer.signData(Uint8Array.from(serializedTx));
         tx.addSignature(publicKey, node_buffer_1.Buffer.from(signature));
         const id = bs58_1.default.encode(signature);
         await this.submitTx(tx, id);

package/lib/cjs/common/turbo.js

@@ -108,6 +108,12 @@ class TurboUnauthenticatedClient {
         wallets.pol = wallets.matic;
         return wallets;
     }
+    /**
+     * Returns a list of all delegated payment approvals for the user.
+     */
+    getDelegatedPaymentApprovals(p) {
+        return this.paymentService.getDelegatedPaymentApprovals(p);
+    }
 }
 exports.TurboUnauthenticatedClient = TurboUnauthenticatedClient;
 class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
@@ -118,8 +124,14 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     /**
      * Returns the current balance of the user's wallet in 'winc'.
      */
-    getBalance(address) {
-        return this.paymentService.getBalance(address);
+    getBalance(userAddress) {
+        return this.paymentService.getBalance(userAddress);
+    }
+    /**
+     * Returns a list of all delegated payment approvals for the user.
+     */
+    getDelegatedPaymentApprovals(p = {}) {
+        return this.paymentService.getDelegatedPaymentApprovals(p);
     }
     /**
      * Signs and uploads raw data to the Turbo Upload Service.
@@ -142,5 +154,22 @@ class TurboAuthenticatedClient extends TurboUnauthenticatedClient {
     topUpWithTokens(p) {
         return this.paymentService.topUpWithTokens(p);
     }
+    /**
+     * Creates a data item with tags that designate it as a delegated payment approval.
+     * Signs the data item and sends it to the Turbo Upload Service, which will verify
+     * the signature and forward the admin action towards the Turbo Payment Service.
+     */
+    createDelegatedPaymentApproval(p) {
+        return this.uploadService.createDelegatedPaymentApproval(p);
+    }
+    /**
+     * Creates a data item with tags that designate it as a revoke action for delegated
+     * payment approvals for target revokedAddress. Signs the data item and sends it to
+     * the Turbo Upload Service, which will verify the signature and forward the admin
+     * action towards the Turbo Payment Service.
+     */
+    revokeDelegatedPaymentApprovals(p) {
+        return this.uploadService.revokeDelegatedPaymentApprovals(p);
+    }
 }
 exports.TurboAuthenticatedClient = TurboAuthenticatedClient;

package/lib/cjs/common/upload.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboAuthenticatedBaseUploadService = exports.TurboUnauthenticatedUploadService = exports.defaultUploadServiceURL = exports.developmentUploadServiceURL = void 0;
+exports.TurboAuthenticatedBaseUploadService = exports.TurboUnauthenticatedUploadService = exports.defaultUploadServiceURL = exports.developmentUploadServiceURL = exports.revokeDelegatePaymentApprovalTagName = exports.approvalExpiresBySecondsTagName = exports.approvalAmountTagName = exports.createDelegatedPaymentApprovalTagName = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -17,9 +17,14 @@ exports.TurboAuthenticatedBaseUploadService = exports.TurboUnauthenticatedUpload
  * limitations under the License.
  */
 const node_buffer_1 = require("node:buffer");
+const node_stream_1 = require("node:stream");
 const plimit_lit_1 = require("plimit-lit");
 const http_js_1 = require("./http.js");
 const logger_js_1 = require("./logger.js");
+exports.createDelegatedPaymentApprovalTagName = 'x-approve-payment';
+exports.approvalAmountTagName = 'x-amount';
+exports.approvalExpiresBySecondsTagName = 'x-expires-seconds';
+exports.revokeDelegatePaymentApprovalTagName = 'x-delete-payment-approval';
 exports.developmentUploadServiceURL = 'https://upload.ardrive.dev';
 exports.defaultUploadServiceURL = 'https://upload.ardrive.io';
 class TurboUnauthenticatedUploadService {
@@ -61,17 +66,25 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             dataItemOpts,
         });
         const signedDataItem = dataItemStreamFactory();
-        const fileSize = dataItemSizeFactory();
         this.logger.debug('Uploading signed data item...');
         // TODO: add p-limit constraint or replace with separate upload class
+        const headers = {
+            'content-type': 'application/octet-stream',
+            'content-length': `${dataItemSizeFactory()}`,
+        };
+        if (dataItemOpts !== undefined && dataItemOpts.paidBy !== undefined) {
+            const paidBy = Array.isArray(dataItemOpts.paidBy)
+                ? dataItemOpts.paidBy
+                : [dataItemOpts.paidBy];
+            if (dataItemOpts.paidBy.length > 0) {
+                headers['x-paid-by'] = paidBy;
+            }
+        }
         return this.httpService.post({
             endpoint: `/tx/${this.token}`,
             signal,
             data: signedDataItem,
-            headers: {
-                'content-type': 'application/octet-stream',
-                'content-length': `${fileSize}`,
-            },
+            headers,
         });
     }
     async generateManifest({ paths, indexFile, fallbackFile, }) {
@@ -182,5 +195,51 @@ class TurboAuthenticatedBaseUploadService extends TurboUnauthenticatedUploadServ
             manifestResponse,
         };
     }
+    async createDelegatedPaymentApproval({ approvedAddress, approvedWincAmount, expiresBySeconds, }) {
+        const dataItemOpts = {
+            tags: [
+                { name: exports.createDelegatedPaymentApprovalTagName, value: approvedAddress },
+                { name: exports.approvalAmountTagName, value: approvedWincAmount.toString() },
+            ],
+        };
+        if (expiresBySeconds !== undefined) {
+            dataItemOpts.tags.push({
+                name: exports.approvalExpiresBySecondsTagName,
+                value: expiresBySeconds.toString(),
+            });
+        }
+        const nonceData = node_buffer_1.Buffer.from(approvedAddress + approvedWincAmount + Date.now());
+        const { createdApproval, ...uploadResponse } = await this.uploadFile({
+            fileStreamFactory: () => node_stream_1.Readable.from(nonceData),
+            fileSizeFactory: () => nonceData.byteLength,
+            dataItemOpts,
+        });
+        if (!createdApproval) {
+            throw new Error('Failed to create delegated payment approval but upload has succeeded\n' +
+                JSON.stringify(uploadResponse));
+        }
+        return createdApproval;
+    }
+    async revokeDelegatedPaymentApprovals({ revokedAddress, }) {
+        const dataItemOpts = {
+            tags: [
+                {
+                    name: exports.revokeDelegatePaymentApprovalTagName,
+                    value: revokedAddress,
+                },
+            ],
+        };
+        const nonceData = node_buffer_1.Buffer.from(revokedAddress + Date.now());
+        const { revokedApprovals, ...uploadResponse } = await this.uploadFile({
+            fileStreamFactory: () => node_stream_1.Readable.from(nonceData),
+            fileSizeFactory: () => nonceData.byteLength,
+            dataItemOpts,
+        });
+        if (!revokedApprovals) {
+            throw new Error('Failed to revoke delegated payment approvals but upload has succeeded\n' +
+                JSON.stringify(uploadResponse));
+        }
+        return revokedApprovals;
+    }
 }
 exports.TurboAuthenticatedBaseUploadService = TurboAuthenticatedBaseUploadService;

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

package/lib/esm/cli/cli.js

@@ -18,8 +18,11 @@
 // eslint-disable-next-line header/header -- This is a CLI file
 import { program } from 'commander';
 import { version } from '../version.js';
+import { createApproval } from './commands/createApproval.js';
 import { balance, cryptoFund, price, topUp, uploadFile, uploadFolder, } from './commands/index.js';
-import { globalOptions, optionMap, uploadFileOptions, uploadFolderOptions, walletOptions, } from './options.js';
+import { listApprovals } from './commands/listApprovals.js';
+import { revokeApprovals } from './commands/revokeApprovals.js';
+import { createApprovalOptions, globalOptions, listApprovalsOptions, optionMap, revokeApprovalsOptions, uploadFileOptions, uploadFolderOptions, walletOptions, } from './options.js';
 import { applyOptions, runCommand } from './utils.js';
 applyOptions(program
     .name('turbo')
@@ -46,6 +49,21 @@ applyOptions(program
     .description('Get the current Credits estimate for byte, crypto, or fiat value'), [optionMap.value, optionMap.type]).action(async (_commandOptions, command) => {
     await runCommand(command, price);
 });
+applyOptions(program
+    .command('create-approval')
+    .description('Create a Turbo delegated payment approval'), createApprovalOptions).action(async (_commandOptions, command) => {
+    await runCommand(command, createApproval);
+});
+applyOptions(program
+    .command('revoke-approvals')
+    .description('Revokes all Turbo delegated payment approvals for given address'), revokeApprovalsOptions).action(async (_commandOptions, command) => {
+    await runCommand(command, revokeApprovals);
+});
+applyOptions(program
+    .command('list-approvals')
+    .description('Lists all Turbo delegated payment approvals for given address or wallet'), listApprovalsOptions).action(async (_commandOptions, command) => {
+    await runCommand(command, listApprovals);
+});
 if (process.argv[1].includes('bin/turbo') || // Running from global .bin
     process.argv[1].includes('cli/cli') // Running from source
 ) {

package/lib/esm/cli/commands/balance.js

@@ -13,24 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { BigNumber } from 'bignumber.js';
 import { TurboFactory } from '../../node/factory.js';
+import { wincPerCredit } from '../constants.js';
 import { addressOrPrivateKeyFromOptions, configFromOptions } from '../utils.js';
 export async function balance(options) {
     const config = configFromOptions(options);
     const { address, privateKey } = await addressOrPrivateKeyFromOptions(options);
-    if (address !== undefined) {
-        const turbo = TurboFactory.unauthenticated(config);
-        const { winc } = await turbo.getBalance(address);
-        console.log(`Turbo Balance for Native Address "${address}"\nCredits: ${+winc / 1_000_000_000_000}`);
-        return;
-    }
-    if (privateKey === undefined) {
-        throw new Error('Must provide an (--address) or use a valid wallet');
-    }
-    const turbo = TurboFactory.authenticated({
-        ...config,
-        privateKey,
-    });
-    const { winc } = await turbo.getBalance();
-    console.log(`Turbo Balance for Wallet Address "${await turbo.signer.getNativeAddress()}"\nCredits: ${+winc / 1_000_000_000_000}`);
+    const { effectiveBalance, nativeAddress, winc, controlledWinc } = await (async () => {
+        if (address !== undefined) {
+            return {
+                ...(await TurboFactory.unauthenticated(config).getBalance(address)),
+                nativeAddress: address,
+            };
+        }
+        if (privateKey === undefined) {
+            throw new Error('Must provide an (--address) or use a valid wallet');
+        }
+        const turbo = TurboFactory.authenticated({
+            ...config,
+            privateKey,
+        });
+        return {
+            ...(await turbo.getBalance()),
+            nativeAddress: await turbo.signer.getNativeAddress(),
+        };
+    })();
+    console.log(`Turbo Balance for Native Address "${nativeAddress}"\nEffective Credits: ${+effectiveBalance / wincPerCredit}${winc === controlledWinc
+        ? ''
+        : `\nCredits Shared to Other Wallets: ${BigNumber(controlledWinc)
+            .minus(winc)
+            .div(wincPerCredit)}`}`);
 }

package/lib/esm/cli/commands/createApproval.js

@@ -0,0 +1,36 @@
+/**
+ * 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 { BigNumber } from 'bignumber.js';
+import { turboFromOptions } from '../utils.js';
+export async function createApproval(options) {
+    const { address: approvedAddress, value: creditAmount, expiresBySeconds, } = options;
+    if (approvedAddress === undefined) {
+        throw new Error('Must provide an approved --address to create approval for');
+    }
+    if (creditAmount === undefined) {
+        throw new Error('Must provide a credit --value to create approval for');
+    }
+    const turbo = await turboFromOptions(options);
+    const approvedWincAmount = new BigNumber(creditAmount)
+        .shiftedBy(12)
+        .toFixed(0);
+    const result = await turbo.createDelegatedPaymentApproval({
+        approvedAddress,
+        approvedWincAmount,
+        expiresBySeconds,
+    });
+    console.log(JSON.stringify({ message: 'Created approval:', ...result }, null, 2));
+}

package/lib/esm/cli/commands/cryptoFund.js

@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { BigNumber } from 'bignumber.js';
 import prompts from 'prompts';
 import { tokenToBaseMap } from '../../common/index.js';
 import { TurboFactory } from '../../node/factory.js';
+import { wincPerCredit } from '../constants.js';
 import { configFromOptions, tokenFromOptions, turboFromOptions, } from '../utils.js';
 export async function cryptoFund(options) {
     const value = options.value;
@@ -35,7 +37,7 @@ export async function cryptoFund(options) {
     if (!options.skipConfirmation) {
         const { winc } = await turbo.getWincForToken({ tokenAmount });
         const targetWallet = (await turbo.getTurboCryptoWallets())[token];
-        const credits = (+winc / 1_000_000_000_000).toFixed(12);
+        const credits = BigNumber(winc).dividedBy(wincPerCredit).toFixed(12);
         const { confirm } = await prompts({
             type: 'confirm',
             name: 'confirm',

package/lib/esm/cli/commands/listApprovals.js

@@ -0,0 +1,55 @@
+/**
+ * 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 { TurboFactory } from '../../node/factory.js';
+import { addressOrPrivateKeyFromOptions, configFromOptions } from '../utils.js';
+export async function listApprovals(options) {
+    const config = configFromOptions(options);
+    const { address, privateKey } = await addressOrPrivateKeyFromOptions(options);
+    const { givenApprovals, receivedApprovals, nativeAddress } = await (async () => {
+        if (address !== undefined) {
+            const approvals = await TurboFactory.unauthenticated(config).getDelegatedPaymentApprovals({
+                userAddress: address,
+            });
+            return { ...approvals, nativeAddress: address };
+        }
+        if (privateKey === undefined) {
+            throw new Error('Must provide an (--address) or use a valid wallet');
+        }
+        const turbo = TurboFactory.authenticated({
+            ...config,
+            privateKey,
+        });
+        const approvals = await turbo.getDelegatedPaymentApprovals();
+        return {
+            ...approvals,
+            nativeAddress: await turbo.signer.getNativeAddress(),
+        };
+    })();
+    const hasApprovals = givenApprovals?.length === 0 && receivedApprovals?.length === 0;
+    const body = {
+        message: `${hasApprovals ? 'No approvals found' : 'Approvals found'}` +
+            ` for native address '${nativeAddress}'`,
+        givenApprovals,
+        receivedApprovals,
+    };
+    if (givenApprovals?.length > 0) {
+        body['givenApprovals'] = givenApprovals;
+    }
+    if (receivedApprovals?.length > 0) {
+        body['receivedApprovals'] = receivedApprovals;
+    }
+    console.log(JSON.stringify(body, null, 2));
+}

package/lib/esm/cli/commands/price.js

@@ -17,6 +17,7 @@ import { currencyMap } from '../../common/currency.js';
 import { isTokenType, tokenToBaseMap } from '../../common/index.js';
 import { TurboFactory } from '../../node/factory.js';
 import { fiatCurrencyTypes, isCurrency, tokenTypes } from '../../types.js';
+import { wincPerCredit } from '../constants.js';
 import { configFromOptions } from '../utils.js';
 export async function price(options) {
     const value = options.value;
@@ -45,5 +46,5 @@ export async function price(options) {
         }
         throw new Error(`Invalid price type!\nMust be one of: bytes, ${fiatCurrencyTypes.join(', ') + ' ' + tokenTypes.join(', ')}`);
     })();
-    console.log(`Current price estimate for ${value} ${type} is ~${(+winc / 1_000_000_000_000).toFixed(12)} Credits`);
+    console.log(`Current price estimate for ${value} ${type} is ~${(+winc / wincPerCredit).toFixed(12)} Credits`);
 }

package/lib/esm/cli/commands/revokeApprovals.js

@@ -0,0 +1,12 @@
+import { turboFromOptions } from '../utils.js';
+export async function revokeApprovals(options) {
+    const { address: revokedAddress } = options;
+    if (revokedAddress === undefined) {
+        throw new Error('Must provide an approved --address to revoke approvals for');
+    }
+    const turbo = await turboFromOptions(options);
+    const revokedApprovals = await turbo.revokeDelegatedPaymentApprovals({
+        revokedAddress,
+    });
+    console.log(JSON.stringify({ message: 'Revoked approvals', revokedApprovals }, null, 2));
+}

package/lib/esm/cli/commands/uploadFile.js

@@ -15,18 +15,19 @@
  */
 import { createReadStream, statSync } from 'fs';
 import { turboCliTags } from '../constants.js';
-import { turboFromOptions } from '../utils.js';
+import { paidByFromOptions, turboFromOptions } from '../utils.js';
 export async function uploadFile(options) {
     const { filePath } = options;
     if (filePath === undefined) {
         throw new Error('Must provide a --file-path to upload');
     }
     const turbo = await turboFromOptions(options);
+    const paidBy = await paidByFromOptions(options, turbo);
     const fileSize = statSync(filePath).size;
     const result = await turbo.uploadFile({
         fileStreamFactory: () => createReadStream(filePath),
         fileSizeFactory: () => fileSize,
-        dataItemOpts: { tags: [...turboCliTags] }, // TODO: Inject user tags
+        dataItemOpts: { tags: [...turboCliTags], paidBy }, // TODO: Inject user tags
     });
     console.log('Uploaded file:', JSON.stringify(result, null, 2));
 }