feat(delegated payments): add revoke approvals to SDK and CLI PE-6754

src/cli/cli.ts

@@ -29,10 +29,12 @@ import {
   uploadFile,
   uploadFolder,
 } from './commands/index.js';
+import { revokeApprovals } from './commands/revokeApprovals.js';
 import {
   createApprovalOptions,
   globalOptions,
   optionMap,
+  revokeApprovalsOptions,
   uploadFileOptions,
   uploadFolderOptions,
   walletOptions,
@@ -103,6 +105,16 @@ applyOptions(
 ).action(async (_commandOptions, command: 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: Command) => {
+  await runCommand(command, revokeApprovals);
+});
 
 if (
   process.argv[1].includes('bin/turbo') || // Running from global .bin

src/cli/commands/revokeApprovals.ts

@@ -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 { RevokeApprovalsOptions } from '../types.js';
+import { turboFromOptions } from '../utils.js';
+
+export async function revokeApprovals(
+  options: RevokeApprovalsOptions,
+): Promise<void> {
+  const { address: revokedAddress } = options;
+  if (revokedAddress === undefined) {
+    throw new Error(
+      'Must provide an approved --address to create approval for',
+    );
+  }
+
+  const turbo = await turboFromOptions(options);
+
+  const result = await turbo.revokeDelegatedPaymentApprovals({
+    revokedAddress,
+  });
+
+  console.log('Created approval:', JSON.stringify(result, null, 2));
+}

src/cli/options.ts

@@ -170,3 +170,5 @@ export const createApprovalOptions = [
   optionMap.address,
   optionMap.expiresBySeconds,
 ];
+
+export const revokeApprovalsOptions = [...walletOptions, optionMap.address];

src/cli/types.ts

@@ -68,3 +68,7 @@ export type CreateApprovalOptions = WalletOptions & {
   value: string | undefined;
   expiresBySeconds: number | undefined;
 };
+
+export type RevokeApprovalsOptions = WalletOptions & {
+  address: string | undefined;
+};

src/common/turbo.ts

@@ -35,6 +35,7 @@ import {
   TurboFundWithTokensParams,
   TurboPriceResponse,
   TurboRatesResponse,
+  TurboRevokeDelegatePaymentApprovalsParams,
   TurboSignedDataItemFactory,
   TurboSubmitFundTxResponse,
   TurboUnauthenticatedClientConfiguration,
@@ -277,4 +278,17 @@ export class TurboAuthenticatedClient
   ): Promise<TurboUploadDataItemResponse> {
     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: TurboRevokeDelegatePaymentApprovalsParams,
+  ): Promise<TurboUploadDataItemResponse> {
+    return this.uploadService.revokeDelegatedPaymentApprovals(p);
+  }
 }

src/common/upload.ts

@@ -28,6 +28,7 @@ import {
   TurboDataItemSigner,
   TurboFileFactory,
   TurboLogger,
+  TurboRevokeDelegatePaymentApprovalsParams,
   TurboSignedDataItemFactory,
   TurboUnauthenticatedUploadServiceConfiguration,
   TurboUnauthenticatedUploadServiceInterface,
@@ -336,4 +337,24 @@ export abstract class TurboAuthenticatedBaseUploadService
       dataItemOpts,
     });
   }
+
+  public async revokeDelegatedPaymentApprovals({
+    revokedAddress,
+  }: TurboRevokeDelegatePaymentApprovalsParams): Promise<TurboUploadDataItemResponse> {
+    const dataItemOpts = {
+      tags: [
+        {
+          name: revokeDelegatePaymentApprovalTagName,
+          value: revokedAddress,
+        },
+      ],
+    };
+
+    const nonceData = Buffer.from(revokedAddress + Date.now());
+    return this.uploadFile({
+      fileStreamFactory: () => Readable.from(nonceData),
+      fileSizeFactory: () => nonceData.byteLength,
+      dataItemOpts,
+    });
+  }
 }

src/types.ts

@@ -213,6 +213,10 @@ export type TurboCreateDelegatedPaymentApprovalParams = {
   expiresBySeconds?: number;
 };
 
+export type TurboRevokeDelegatePaymentApprovalsParams = {
+  revokedAddress: string;
+};
+
 export type TurboUploadFolderResponse = {
   fileResponses: TurboUploadDataItemResponse[];
   manifestResponse?: TurboUploadDataItemResponse;
@@ -586,6 +590,9 @@ export interface TurboAuthenticatedUploadServiceInterface
   createDelegatedPaymentApproval(
     p: TurboCreateDelegatedPaymentApprovalParams,
   ): Promise<TurboUploadDataItemResponse>;
+  revokeDelegatedPaymentApprovals(
+    p: TurboRevokeDelegatePaymentApprovalsParams,
+  ): Promise<TurboUploadDataItemResponse>;
 }
 
 export interface TurboUnauthenticatedClientInterface