Add getOperationResults to cleints

Add getOperationResults to bls-wallet-clients to allow consumers to more easily get at operation errors.
Change existing test case to use getOperationResults.
Add message to require used to prevent ownership changes to proxy admin.

contracts/clients/README.md

@@ -80,6 +80,24 @@ const verificationGateway = VerificationGateway__factory.connect(
 await verificationGateway.processBundle(bundle);
 ```
 
+You can get the results of the operations in a bundle using `getOperationResults`.
+
+```ts
+import { getOperationResults } from 'bls-wallet-clients';
+
+...
+
+const txn = await verificationGateway.processBundle(bundle);
+const txnReceipt = txn.wait();
+const opResults = getOperationResults(txnReceipt);
+
+// Includes data from WalletOperationProcessed event,
+// as well as parsed errors with action index
+const { error } = opResults[0];
+console.log(error?.actionIndex); // ex. 0 (as BigNumber)
+console.log(error?.message); // ex. "some require failure message"
+```
+
 ## Signer
 
 Utilities for signing, aggregating and verifying transaction bundles using the

contracts/clients/src/OperationResults.ts

@@ -0,0 +1,103 @@
+import { BigNumber, ContractReceipt, utils } from "ethers";
+import { ActionData } from "./signer";
+
+type OperationResultError = {
+  actionIndex: BigNumber;
+  message: string;
+};
+
+export type OperationResult = {
+  walletAddress: string;
+  nonce: BigNumber;
+  actions: ActionData[];
+  success: Boolean;
+  results: string[];
+  error?: OperationResultError;
+};
+
+const getError = (
+  success: boolean,
+  results: string[],
+): OperationResultError | undefined => {
+  if (success) {
+    return undefined;
+  }
+
+  // Single event "WalletOperationProcessed(address indexed wallet, uint256 nonce, bool success, bytes[] results)"
+  // Get the first (only) result from "results" argument.
+  const [errorResult] = results;
+  // remove methodId (4bytes after 0x)
+  const errorArgBytesString = `0x${errorResult.substring(10)}`;
+  const errorString = utils.defaultAbiCoder.decode(
+    ["string"],
+    errorArgBytesString,
+  )[0]; // decoded bytes is a string of the action index that errored.
+
+  const splitErrorString = errorString.split(" - ");
+  if (splitErrorString.length !== 2) {
+    throw new Error("unexpected error message format");
+  }
+
+  return {
+    actionIndex: BigNumber.from(splitErrorString[0]),
+    message: splitErrorString[1],
+  };
+};
+
+export const getOperationResults = (
+  txnReceipt: ContractReceipt,
+): OperationResult[] => {
+  if (!txnReceipt.events || !txnReceipt.events.length) {
+    throw new Error(
+      `no events found in transaction ${txnReceipt.transactionHash}`,
+    );
+  }
+
+  const walletOpProcessedEvents = txnReceipt.events.filter(
+    (e) => e.event === "WalletOperationProcessed",
+  );
+  if (!walletOpProcessedEvents.length) {
+    throw new Error(
+      `no WalletOperationProcessed events found in transaction ${txnReceipt.transactionHash}`,
+    );
+  }
+
+  return walletOpProcessedEvents.reduce<OperationResult[]>(
+    (opResults, { args }) => {
+      if (!args) {
+        throw new Error("WalletOperationProcessed event missing args");
+      }
+      const { wallet, nonce, actions: rawActions, success, results } = args;
+
+      const actions = rawActions.map(
+        ({
+          ethValue,
+          contractAddress,
+          encodedFunction,
+        }: {
+          ethValue: BigNumber;
+          contractAddress: string;
+          encodedFunction: string;
+        }) => ({
+          ethValue,
+          contractAddress,
+          encodedFunction,
+        }),
+      );
+      const error = getError(success, results);
+
+      return [
+        ...opResults,
+        {
+          walletAddress: wallet,
+          nonce,
+          actions,
+          success,
+          results,
+          error,
+        },
+      ];
+    },
+    [],
+  );
+};

contracts/clients/src/index.ts

@@ -24,6 +24,8 @@ import {
   validateMultiConfig,
 } from "./MultiNetworkConfig";
 
+import { OperationResult, getOperationResults } from "./OperationResults";
+
 export * from "./signer";
 
 export {
@@ -35,6 +37,8 @@ export {
   MultiNetworkConfig,
   getMultiConfig,
   validateMultiConfig,
+  OperationResult,
+  getOperationResults,
   // eslint-disable-next-line camelcase
   VerificationGateway__factory,
   VerificationGateway,

contracts/contracts/VerificationGateway.sol

@@ -195,7 +195,9 @@ contract VerificationGateway
 
         // ensure not calling Ownable functions of ProxyAdmin
         require((selectorId != Ownable.transferOwnership.selector)
-            && (selectorId != Ownable.renounceOwnership.selector));
+            && (selectorId != Ownable.renounceOwnership.selector),
+            "VG: cannot change ownership"
+        );
 
         wallet.setAnyPending();
 

contracts/test/walletAction-test.ts

@@ -10,6 +10,7 @@ import { parseEther, solidityPack } from "ethers/lib/utils";
 import deployAndRunPrecompileCostEstimator from "../shared/helpers/deployAndRunPrecompileCostEstimator";
 // import splitHex256 from "../shared/helpers/splitHex256";
 import { defaultDeployerAddress } from "../shared/helpers/deployDeployer";
+import { getOperationResults } from "../clients/src";
 
 describe("WalletActions", async function () {
   if (`${process.env.DEPLOYER_DEPLOYMENT}` === "true") {
@@ -322,15 +323,12 @@ describe("WalletActions", async function () {
       )
     ).wait();
 
-    // Single event "WalletOperationProcessed(address indexed wallet, uint256 nonce, bool success, bytes[] results)"
-    // Get the first (only) result from "results" argument.
-    const result = r.events[0].args.results[0]; // For errors this is "Error(string)"
-    const errorArgBytesString: string = "0x" + result.substring(10); // remove methodId (4bytes after 0x)
-    const errorString = ethers.utils.defaultAbiCoder.decode(
-      ["string"],
-      errorArgBytesString,
-    )[0]; // decoded bytes is a string of the action index that errored.
-    expect(errorString).to.equal("1 - ERC20: transfer from the zero address");
+    const opResults = getOperationResults(r);
+    expect(opResults).to.have.lengthOf(1);
+    expect(opResults[0].error.actionIndex.toNumber()).to.eql(1);
+    expect(opResults[0].error.message).to.eql(
+      "ERC20: transfer from the zero address",
+    );
 
     const recipientBalance = await th.testToken.balanceOf(recipient.address);