feat: add swap+send STX typings

packages/transaction-controller/src/TransactionController.ts

@@ -444,13 +444,21 @@ export type TransactionControllerTransactionNewSwapEvent = {
 };
 
 /**
- * Represents the `TransactionController:transactionNewSwapApproval` event.
+ * Represents the `TransactionController:transactionNewSwapAndSend` event.
  */
 export type TransactionControllerTransactionNewSwapAndSendEvent = {
   type: `${typeof controllerName}:transactionNewSwapAndSend`;
   payload: [{ transactionMeta: TransactionMeta }];
 };
 
+/**
+ * Represents the `TransactionController:transactionNewSwapAndSendApproval` event.
+ */
+export type TransactionControllerTransactionNewSwapAndSendApprovalEvent = {
+  type: `${typeof controllerName}:transactionNewSwapAndSendApproval`;
+  payload: [{ transactionMeta: TransactionMeta }];
+};
+
 /**
  * Represents the `TransactionController:transactionPublishingSkipped` event.
  */
@@ -521,6 +529,7 @@ export type TransactionControllerEvents =
   | TransactionControllerTransactionNewSwapApprovalEvent
   | TransactionControllerTransactionNewSwapEvent
   | TransactionControllerTransactionNewSwapAndSendEvent
+  | TransactionControllerTransactionNewSwapAndSendApprovalEvent
   | TransactionControllerTransactionPublishingSkipped
   | TransactionControllerTransactionRejectedEvent
   | TransactionControllerTransactionStatusUpdatedEvent

packages/transaction-controller/src/types.ts

@@ -42,6 +42,20 @@ export type TransactionMeta = TransactionMetaBase &
  * Information about a single transaction such as status and block number.
  */
 type TransactionMetaBase = {
+  /**
+   * Approval to be ran immediately before the transaction created with `txParams`.
+   */
+  approvalTx?: {
+    data?: TransactionParams;
+    params?: {
+      requireApproval?: boolean;
+      type?: TransactionType;
+      swaps?: {
+        meta?: Partial<TransactionMeta>;
+      };
+    };
+  };
+
   /**
    * ID of the transaction that approved the swap token transfer.
    */
@@ -642,6 +656,14 @@ export enum TransactionType {
   // eslint-disable-next-line @typescript-eslint/naming-convention
   swapAndSend = 'swapAndSend',
 
+  /**
+   * At a contract level, identical to the swapApproval type but requested
+   * during the swap+send flow and only for the amount needed for the trade
+   */
+  // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  swapAndSendApproval = 'swapAndSendApproval',
+
   /**
    * Similar to the approve type, a swap approval is a special case of ERC20
    * approve method that requests an allowance of the token to spend on behalf

packages/transaction-controller/src/utils/swaps.test.ts

@@ -375,6 +375,60 @@ describe('updateSwapsTransaction', () => {
       swapAndSendRecipient,
     });
   });
+
+  it('should update swap and send approval transaction and publish TransactionController:transactionNewSwapAndSendApproval', () => {
+    const sourceTokenSymbol = 'ETH';
+    const type = TransactionType.swapAndSendApproval;
+
+    swaps.meta = {
+      sourceTokenSymbol,
+      type,
+    };
+    transactionType = TransactionType.swapAndSendApproval;
+
+    const transactionNewSwapAndSendApprovalEventListener = jest.fn();
+    messenger.subscribe(
+      'TransactionController:transactionNewSwapAndSendApproval',
+      transactionNewSwapAndSendApprovalEventListener,
+    );
+
+    updateSwapsTransaction(transactionMeta, transactionType, swaps, request);
+    expect(
+      transactionNewSwapAndSendApprovalEventListener,
+    ).toHaveBeenCalledTimes(1);
+    expect(transactionNewSwapAndSendApprovalEventListener).toHaveBeenCalledWith(
+      {
+        transactionMeta: {
+          ...transactionMeta,
+          sourceTokenSymbol,
+          type,
+        },
+      },
+    );
+  });
+
+  it('should return the swap and send approval transaction updated with information', () => {
+    const sourceTokenSymbol = 'ETH';
+    const type = TransactionType.swapAndSendApproval;
+
+    swaps.meta = {
+      sourceTokenSymbol,
+      type,
+    };
+    transactionType = TransactionType.swapAndSendApproval;
+
+    const updatedSwapsTransaction = updateSwapsTransaction(
+      transactionMeta,
+      transactionType,
+      swaps,
+      request,
+    );
+    expect(updatedSwapsTransaction).toStrictEqual({
+      ...transactionMeta,
+      sourceTokenSymbol,
+      type,
+    });
+  });
 });
 
 describe('updatePostTransactionBalance', () => {

packages/transaction-controller/src/utils/swaps.ts

@@ -109,6 +109,7 @@ export const SWAPS_CHAINID_DEFAULT_TOKEN_MAP = {
 export const SWAP_TRANSACTION_TYPES = [
   TransactionType.swap,
   TransactionType.swapAndSend,
+  TransactionType.swapAndSendApproval,
   TransactionType.swapApproval,
 ];
 
@@ -193,6 +194,19 @@ export function updateSwapsTransaction(
     });
   }
 
+  if (transactionType === TransactionType.swapAndSendApproval) {
+    updatedTransactionMeta = updateSwapApprovalTransaction(
+      transactionMeta,
+      swapsMeta,
+    );
+    messenger.publish(
+      'TransactionController:transactionNewSwapAndSendApproval',
+      {
+        transactionMeta: updatedTransactionMeta,
+      },
+    );
+  }
+
   if (transactionType === TransactionType.swap) {
     updatedTransactionMeta = updateSwapTransaction(transactionMeta, swapsMeta);
     messenger.publish('TransactionController:transactionNewSwap', {
@@ -343,6 +357,7 @@ function updateSwapTransaction(
  *
  * @param transactionMeta - Transaction meta object to update
  * @param propsToUpdate - Properties to update
+ * @param propsToUpdate.approvalTx - The parameters of the approval transaction
  * @param propsToUpdate.approvalTxId - Transaction id of the approval transaction
  * @param propsToUpdate.destinationTokenAddress - Address of the token to be received
  * @param propsToUpdate.destinationTokenAmount - The raw amount of the destination token
@@ -362,6 +377,7 @@ function updateSwapTransaction(
 function updateSwapAndSendTransaction(
   transactionMeta: TransactionMeta,
   {
+    approvalTx,
     approvalTxId,
     destinationTokenAddress,
     destinationTokenAmount,
@@ -378,9 +394,13 @@ function updateSwapAndSendTransaction(
     type,
   }: Partial<TransactionMeta>,
 ): TransactionMeta {
-  validateIfTransactionUnapproved(transactionMeta, 'updateSwapTransaction');
+  validateIfTransactionUnapproved(
+    transactionMeta,
+    'updateSwapAndSendTransaction',
+  );
 
   let swapTransaction = {
+    approvalTx,
     approvalTxId,
     destinationTokenAddress,
     destinationTokenAmount,

packages/user-operation-controller/src/UserOperationController.test.ts

@@ -424,6 +424,7 @@ describe('UserOperationController', () => {
           smartContractAccount,
           swaps: {
             approvalTxId: 'testTxId',
+            approvalTx: { data: { from: 'from' } },
             destinationTokenAmount: '0x1',
             destinationTokenAddress: '0x1',
             destinationTokenDecimals: 3,
@@ -445,6 +446,7 @@ describe('UserOperationController', () => {
         expect.objectContaining({
           swapsMetadata: {
             approvalTxId: 'testTxId',
+            approvalTx: { data: { from: 'from' } },
             destinationTokenAmount: '0x1',
             destinationTokenAddress: '0x1',
             destinationTokenDecimals: 3,
@@ -480,6 +482,7 @@ describe('UserOperationController', () => {
         expect.objectContaining({
           swapsMetadata: {
             approvalTxId: null,
+            approvalTx: null,
             destinationTokenAddress: null,
             destinationTokenAmount: null,
             destinationTokenDecimals: null,

packages/user-operation-controller/src/UserOperationController.ts

@@ -141,6 +141,16 @@ export type AddUserOperationRequest = {
 };
 
 export type AddUserOperationSwapOptions = {
+  approvalTx?: {
+    data: TransactionParams;
+    params?: {
+      requireApproval: boolean;
+      type: TransactionType;
+      swaps?: {
+        meta?: Partial<TransactionMeta>;
+      };
+    };
+  };
   approvalTxId?: string;
   destinationTokenAddress?: string;
   destinationTokenAmount?: string;
@@ -446,6 +456,7 @@ export class UserOperationController extends BaseController<
       status: UserOperationStatus.Unapproved,
       swapsMetadata: swaps
         ? {
+            approvalTx: swaps.approvalTx ?? null,
             approvalTxId: swaps.approvalTxId ?? null,
             destinationTokenAddress: swaps.destinationTokenAddress ?? null,
             destinationTokenAmount: swaps.destinationTokenAmount ?? null,

packages/user-operation-controller/src/types.ts

@@ -1,4 +1,5 @@
 import type {
+  TransactionMeta,
   TransactionParams,
   TransactionType,
   UserFeeLevel,
@@ -336,6 +337,18 @@ export type UserOperationReceipt = {
 
 /** Information specific to user operations created from swap transactions. */
 export type SwapsMetadata = {
+  /** Transaction data for approval to be ran immediately before the swap transaction */
+  approvalTx?: {
+    data: TransactionParams;
+    params?: {
+      requireApproval?: boolean;
+      type?: TransactionType;
+      swaps?: {
+        meta?: Partial<TransactionMeta>;
+      };
+    };
+  } | null;
+
   /** ID of the associated approval transaction. */
   approvalTxId: string | null;
 

packages/user-operation-controller/src/utils/transaction.test.ts

@@ -259,6 +259,7 @@ describe('transation', () => {
         ...USER_OPERATION_METADATA_MOCK,
         swapsMetadata: {
           approvalTxId: 'testTxId',
+          approvalTx: { test: 'value' },
           destinationTokenAddress: '0x2',
           destinationTokenDecimals: '3',
           destinationTokenSymbol: 'TEST',
@@ -274,6 +275,7 @@ describe('transation', () => {
       expect(transactionMetadata).toStrictEqual(
         expect.objectContaining({
           approvalTxId: 'testTxId',
+          approvalTx: { test: 'value' },
           destinationTokenAddress: '0x2',
           destinationTokenDecimals: '3',
           destinationTokenSymbol: 'TEST',

packages/user-operation-controller/src/utils/transaction.ts

@@ -105,6 +105,7 @@ export function getTransactionMetadata(
   delete txParams.gasPrice;
 
   const swaps = {
+    approvalTx: swapsMetadata?.approvalTx ?? undefined,
     approvalTxId: swapsMetadata?.approvalTxId ?? undefined,
     destinationTokenAddress:
       swapsMetadata?.destinationTokenAddress ?? undefined,

packages/user-operation-controller/src/utils/validation.test.ts

@@ -341,7 +341,7 @@ describe('validation', () => {
         'type',
         'wrong type',
         123,
-        'Expected one of `"cancel","contractInteraction","contractDeployment","eth_decrypt","eth_getEncryptionPublicKey","incoming","personal_sign","retry","simpleSend","eth_signTypedData","smart","swap","swapAndSend","swapApproval","approve","safetransferfrom","transfer","transferfrom","setapprovalforall","increaseAllowance"`, but received: 123',
+        'Expected one of `"cancel","contractInteraction","contractDeployment","eth_decrypt","eth_getEncryptionPublicKey","incoming","personal_sign","retry","simpleSend","eth_signTypedData","smart","swap","swapAndSend","swapAndSendApproval","swapApproval","approve","safetransferfrom","transfer","transferfrom","setapprovalforall","increaseAllowance"`, but received: 123',
       ],
     ])(
       'throws if %s is %s',

packages/user-operation-controller/src/utils/validation.ts

@@ -67,6 +67,7 @@ export function validateAddUserOperationOptions(
     ),
     swaps: optional(
       object({
+        approvalTx: optional(object()),
         approvalTxId: optional(string()),
         destinationTokenAddress: optional(string()),
         destinationTokenDecimals: optional(number()),