Split logic

Add constants.
Add version validation.

Author: matthewwalsh0

app/scripts/lib/transaction/eip5792.test.ts

@@ -155,6 +155,21 @@ describe('EIP-5792', () => {
       ).toStrictEqual({ id: BATCH_ID_MOCK });
     });
 
+    it('throws if version not supported', async () => {
+      await expect(
+        processSendCalls(
+          {
+            addTransactionBatch: addTransactionBatchMock,
+            getDisabledAccountUpgradeChains:
+              getDisabledAccountUpgradeChainsMock,
+          },
+          messenger,
+          { ...SEND_CALLS_MOCK, version: '2.0' },
+          REQUEST_MOCK,
+        ),
+      ).rejects.toThrow(`Version not supported: Got 2.0, expected 1.0`);
+    });
+
     it('throws if chain ID does not match network client', async () => {
       await expect(
         processSendCalls(

app/scripts/lib/transaction/eip5792.ts

@@ -4,6 +4,7 @@ import {
   Log,
   TransactionController,
   TransactionControllerGetStateAction,
+  TransactionMeta,
   TransactionReceipt,
   TransactionStatus,
 } from '@metamask/transaction-controller';
@@ -22,6 +23,9 @@ type Actions =
 
 export type EIP5792Messenger = Messenger<Actions, never>;
 
+const VERSION_SEND_CALLS = '1.0';
+const VERSION_GET_CALLS_STATUS = '1.0';
+
 export async function processSendCalls(
   hooks: {
     addTransactionBatch: TransactionController['addTransactionBatch'];
@@ -32,7 +36,7 @@ export async function processSendCalls(
   req: JsonRpcRequest & { networkClientId: string; origin?: string },
 ): Promise<SendCallsResult> {
   const { addTransactionBatch, getDisabledAccountUpgradeChains } = hooks;
-  const { calls, capabilities, chainId: requestChainId, from } = params;
+  const { calls, from } = params;
   const { networkClientId, origin } = req;
   const transactions = calls.map((call) => ({ params: call }));
 
@@ -41,46 +45,9 @@ export async function processSendCalls(
     networkClientId,
   ).configuration.chainId;
 
-  if (
-    requestChainId &&
-    requestChainId.toLowerCase() !== dappChainId.toLowerCase()
-  ) {
-    throw rpcErrors.invalidInput(
-      `Chain ID must match the dApp selected network: Got ${requestChainId}, expected ${dappChainId}`,
-    );
-  }
-
-  const requiredTopLevelCapabilities = Object.keys(capabilities ?? {}).filter(
-    (name) => capabilities?.[name].optional !== true,
-  );
-
-  const requiredCallCapabilities = calls.flatMap((call) =>
-    Object.keys(call.capabilities ?? {}).filter(
-      (name) => call.capabilities?.[name].optional !== true,
-    ),
-  );
-
-  const requiredCapabilities = [
-    ...requiredTopLevelCapabilities,
-    ...requiredCallCapabilities,
-  ];
-
-  if (requiredCapabilities?.length) {
-    throw rpcErrors.invalidInput(
-      `Unsupported non-optional capabilities: ${requiredCapabilities.join(
-        ', ',
-      )}`,
-    );
-  }
-
   const disabledChains = getDisabledAccountUpgradeChains();
-  const isDisabled = disabledChains.includes(dappChainId);
 
-  if (isDisabled) {
-    throw rpcErrors.methodNotSupported(
-      `EIP-5792 is not supported for this chain and account - Chain ID: ${dappChainId}, Account: ${from}`,
-    );
-  }
+  validateSendCalls(params, dappChainId, disabledChains);
 
   const { batchId: id } = await addTransactionBatch({
     from,
@@ -104,35 +71,13 @@ export function getCallsStatus(
     throw rpcErrors.invalidInput(`No matching calls found`);
   }
 
-  const {
-    chainId,
-    hash,
-    txReceipt: rawTxReceipt,
-    status: transactionStatus,
-  } = transactions[0];
-
-  let status = GetCallsStatusCode.PENDING;
-
-  if (transactionStatus === TransactionStatus.confirmed) {
-    status = GetCallsStatusCode.CONFIRMED;
-  } else if (transactionStatus === TransactionStatus.failed) {
-    status = hash
-      ? GetCallsStatusCode.REVERTED
-      : GetCallsStatusCode.FAILED_OFFCHAIN;
-  } else if (transactionStatus === TransactionStatus.dropped) {
-    status = GetCallsStatusCode.REVERTED;
-  }
-
-  const txReceipt = rawTxReceipt as unknown as Required<TransactionReceipt> & {
-    transactionHash: Hex;
-  };
-
-  const logs =
-    (txReceipt.logs as (Required<Log> & {
-      data: Hex;
-    })[]) ?? [];
+  const transaction = transactions[0];
+  const { chainId, txReceipt: rawTxReceipt } = transaction;
+  const status = getStatusCode(transaction);
+  const txReceipt = rawTxReceipt as Required<TransactionReceipt> | undefined;
+  const logs = (txReceipt?.logs ?? []) as Required<Log>[];
 
-  const receipts: GetCallsStatusResult['receipts'] = [
+  const receipts: GetCallsStatusResult['receipts'] = txReceipt && [
     {
       blockHash: txReceipt.blockHash as Hex,
       blockNumber: txReceipt.blockNumber as Hex,
@@ -142,13 +87,13 @@ export function getCallsStatus(
         data: log.data,
         topics: log.topics as unknown as Hex[],
       })),
-      status: txReceipt.status as Hex,
+      status: txReceipt.status as '0x0' | '0x1',
       transactionHash: txReceipt.transactionHash,
     },
   ];
 
   return {
-    version: '1.0',
+    version: VERSION_GET_CALLS_STATUS,
     id,
     chainId,
     status,
@@ -160,3 +105,99 @@ export async function getCapabilities(_address: Hex, _chainIds?: Hex[]) {
   // No capabilities currently supported
   return {};
 }
+
+function validateSendCalls(
+  sendCalls: SendCalls,
+  dappChainId: Hex,
+  disabledChains: Hex[],
+) {
+  validateSendCallsVersion(sendCalls);
+  validateSendCallsChainId(sendCalls, dappChainId);
+  validateCapabilities(sendCalls);
+  validateUserDisabled(sendCalls, disabledChains, dappChainId);
+}
+
+function validateSendCallsVersion(sendCalls: SendCalls) {
+  const { version } = sendCalls;
+
+  if (version !== VERSION_SEND_CALLS) {
+    throw rpcErrors.invalidInput(
+      `Version not supported: Got ${version}, expected ${VERSION_SEND_CALLS}`,
+    );
+  }
+}
+
+function validateSendCallsChainId(sendCalls: SendCalls, dappChainId: Hex) {
+  const { chainId: requestChainId } = sendCalls;
+
+  if (
+    requestChainId &&
+    requestChainId.toLowerCase() !== dappChainId.toLowerCase()
+  ) {
+    throw rpcErrors.invalidInput(
+      `Chain ID must match the dApp selected network: Got ${requestChainId}, expected ${dappChainId}`,
+    );
+  }
+}
+
+function validateCapabilities(sendCalls: SendCalls) {
+  const { calls, capabilities } = sendCalls;
+
+  const requiredTopLevelCapabilities = Object.keys(capabilities ?? {}).filter(
+    (name) => capabilities?.[name].optional !== true,
+  );
+
+  const requiredCallCapabilities = calls.flatMap((call) =>
+    Object.keys(call.capabilities ?? {}).filter(
+      (name) => call.capabilities?.[name].optional !== true,
+    ),
+  );
+
+  const requiredCapabilities = [
+    ...requiredTopLevelCapabilities,
+    ...requiredCallCapabilities,
+  ];
+
+  if (requiredCapabilities?.length) {
+    throw rpcErrors.invalidInput(
+      `Unsupported non-optional capabilities: ${requiredCapabilities.join(
+        ', ',
+      )}`,
+    );
+  }
+}
+
+function validateUserDisabled(
+  sendCalls: SendCalls,
+  disabledChains: Hex[],
+  dappChainId: Hex,
+) {
+  const { from } = sendCalls;
+  const isDisabled = disabledChains.includes(dappChainId);
+
+  if (isDisabled) {
+    throw rpcErrors.methodNotSupported(
+      `EIP-5792 is not supported for this chain and account - Chain ID: ${dappChainId}, Account: ${from}`,
+    );
+  }
+}
+
+function getStatusCode(transactionMeta: TransactionMeta) {
+  const { hash, status } = transactionMeta;
+
+  if (status === TransactionStatus.confirmed) {
+    return GetCallsStatusCode.CONFIRMED;
+  }
+
+  if (status === TransactionStatus.failed) {
+    return hash
+      ? GetCallsStatusCode.REVERTED
+      : GetCallsStatusCode.FAILED_OFFCHAIN;
+  }
+
+  if (status === TransactionStatus.dropped) {
+    return GetCallsStatusCode.REVERTED;
+  }
+
+  return GetCallsStatusCode.PENDING;
+}