feat(api): more accurate and simple transaction status tracking

Author: hbriese

api/dbschema/edgeql-js/__spec__.ts

@@ -577,6 +577,7 @@ const $Scheduled = $.makeType<$Scheduled>(_.spec, "23c64270-532c-11ef-863f-6be9e
 const Scheduled: $.$expr_PathNode<$.TypeSet<$Scheduled, $.Cardinality.Many>, null> = _.syntax.$PathNode($.$toSet($Scheduled, $.Cardinality.Many), null);
 
 export type $SimulatedFailureλShape = $.typeutil.flatten<$FailureλShape & {
+  "validationErrors": $.PropertyDesc<$.ArrayType<_std.$str>, $.Cardinality.One, false, false, false, true>;
 }>;
 type $SimulatedFailure = $.ObjectType<"default::SimulatedFailure", $SimulatedFailureλShape, null, [
   ...$Failure['__exclusives__'],
@@ -656,18 +657,18 @@ const Token: $.$expr_PathNode<$.TypeSet<$Token, $.Cardinality.Many>, null> = _.s
 export type $TransactionλShape = $.typeutil.flatten<Omit<$ProposalλShape, "<proposal"> & {
   "maxAmount": $.PropertyDesc<_std.$decimal, $.Cardinality.One, false, false, false, false>;
   "gasLimit": $.PropertyDesc<$uint256, $.Cardinality.One, false, false, false, true>;
-  "executable": $.PropertyDesc<_std.$bool, $.Cardinality.One, false, false, false, true>;
   "unorderedOperations": $.LinkDesc<$Operation, $.Cardinality.AtLeastOne, {}, true, false,  false, false>;
   "operations": $.LinkDesc<$Operation, $.Cardinality.AtLeastOne, {}, false, true,  false, false>;
   "paymaster": $.PropertyDesc<$Address, $.Cardinality.One, false, false, false, false>;
   "feeToken": $.LinkDesc<$Token, $.Cardinality.One, {}, false, false,  false, false>;
   "maxAmountFp": $.PropertyDesc<_std.$bigint, $.Cardinality.One, false, true, false, false>;
   "paymasterEthFees": $.LinkDesc<$PaymasterFees, $.Cardinality.One, {}, true, false,  false, true>;
   "result": $.LinkDesc<$Result, $.Cardinality.AtMostOne, {}, true, false,  false, false>;
-  "status": $.PropertyDesc<$TransactionStatus, $.Cardinality.One, false, true, false, false>;
   "systx": $.LinkDesc<$SystemTx, $.Cardinality.AtMostOne, {}, true, false,  false, false>;
   "results": $.LinkDesc<$Result, $.Cardinality.Many, {}, false, true,  false, false>;
   "systxs": $.LinkDesc<$SystemTx, $.Cardinality.Many, {}, false, true,  false, false>;
+  "status": $.PropertyDesc<$TransactionStatus, $.Cardinality.One, false, true, false, false>;
+  "executable": $.PropertyDesc<_std.$bool, $.Cardinality.One, false, true, false, false>;
   "<transaction[is ConfirmedSuccess]": $.LinkDesc<$ConfirmedSuccess, $.Cardinality.Many, {}, false, false,  false, false>;
   "<transaction[is OptimisticSuccess]": $.LinkDesc<$OptimisticSuccess, $.Cardinality.Many, {}, false, false,  false, false>;
   "<proposal[is PolicyState]": $.LinkDesc<$PolicyState, $.Cardinality.Many, {}, false, false,  false, false>;

api/dbschema/edgeql-js/modules/default.ts

@@ -241,7 +241,9 @@ export namespace $default {
     "cancelled": boolean;
     "scheduledFor": Date;
   }
-  export interface SimulatedFailure extends Failure {}
+  export interface SimulatedFailure extends Failure {
+    "validationErrors": string[];
+  }
   export interface SimulatedSuccess extends Success {}
   export interface SystemTx extends std.$Object {
     "proposal": Transaction;
@@ -269,18 +271,18 @@ export namespace $default {
   export interface Transaction extends Proposal {
     "maxAmount": string;
     "gasLimit": bigint;
-    "executable": boolean;
     "unorderedOperations": Operation[];
     "operations": Operation[];
     "paymaster": string;
     "feeToken": Token;
     "maxAmountFp": bigint;
     "paymasterEthFees": PaymasterFees;
     "result"?: Result | null;
-    "status": TransactionStatus;
     "systx"?: SystemTx | null;
     "results": Result[];
     "systxs": SystemTx[];
+    "status": TransactionStatus;
+    "executable": boolean;
   }
   export type TransactionStatus = "Pending" | "Scheduled" | "Executing" | "Successful" | "Failed" | "Cancelled";
   export interface Transferlike extends Event {

api/dbschema/interfaces.ts

@@ -0,0 +1,23 @@
+CREATE MIGRATION m15nf2s2pczdhpncvwih5festgbvzushr5qfunppqaqahdonqo3nba
+    ONTO m1b4kmwwkkxbx7nv3ze7u3c5td4y35hzgyinz422ny3npt4jpkcc3a
+{
+  ALTER TYPE default::SimulatedFailure {
+      CREATE REQUIRED PROPERTY validationErrors: array<std::str> {
+          SET default := (<array<std::str>>[]);
+      };
+  };
+  ALTER TYPE default::Transaction {
+      ALTER PROPERTY executable {
+          RESET default;
+          USING (((.result IS default::SimulatedSuccess) ?? false));
+      };
+      ALTER PROPERTY status {
+          USING (WITH
+              result := 
+                  .result
+          SELECT
+              std::assert_exists((default::TransactionStatus.Pending IF ((NOT (EXISTS (result)) OR (result IS default::SimulatedSuccess)) OR (result IS default::SimulatedFailure)) ELSE (default::TransactionStatus.Executing IF (result IS default::OptimisticSuccess) ELSE (default::TransactionStatus.Successful IF (result IS default::ConfirmedSuccess) ELSE (default::TransactionStatus.Failed IF (result IS default::ConfirmedFailure) ELSE (default::TransactionStatus.Scheduled IF NOT (result[IS default::Scheduled].cancelled) ELSE default::TransactionStatus.Cancelled))))))
+          );
+      };
+  };
+};

api/dbschema/migrations/00003-m15nf2s.edgeql

@@ -29,21 +29,22 @@ module default {
       on source delete delete target; 
       default := (insert PaymasterFees {}); 
     }
-    required executable: bool { default := false; }
     multi link systxs := .<proposal[is SystemTx];
     link systx: SystemTx { constraint exclusive; } # Latest .timestamp
     multi link results := .<transaction[is Result];
     link result: Result { constraint exclusive; } # Latest .timestamp
     required property status := (
+      with result := .result
       select assert_exists((
-        TransactionStatus.Pending if (not .executable) else
-        TransactionStatus.Executing if (not exists .result) else
-        TransactionStatus.Successful if (.result is ConfirmedSuccess) else
-        TransactionStatus.Failed if (.result is ConfirmedFailure) else
-        TransactionStatus.Scheduled if (not .result[is Scheduled].cancelled) else
-        TransactionStatus.Cancelled
+        TransactionStatus.Pending if (not exists result or result is SimulatedSuccess or result is SimulatedFailure) else
+        TransactionStatus.Executing if (result is OptimisticSuccess) else
+        TransactionStatus.Successful if (result is ConfirmedSuccess) else
+        TransactionStatus.Failed if (result is ConfirmedFailure) else
+        TransactionStatus.Scheduled if (not result[is Scheduled].cancelled) else
+        TransactionStatus.Cancelled # result is Scheduled
       ))
     );
+    required executable := (.result is SimulatedSuccess) ?? false;
   }
 
   type SystemTx {
@@ -93,7 +94,9 @@ module default {
 
   type SimulatedSuccess extending Success {}
 
-  type SimulatedFailure extending Failure {}
+  type SimulatedFailure extending Failure {
+    required validationErrors: array<str> { default := <array<str>>[]; };
+  }
 
   type OptimisticSuccess extending Success {}
 

api/dbschema/transaction.esdl

@@ -2,5 +2,6 @@ insert SimulatedFailure {
   transaction := <Transaction><uuid>$transaction,
   response := <Bytes>$response,
   gasUsed := <bigint>$gasUsed,
-  reason := <str>$reason
+  reason := <str>$reason,
+  validationErrors := <array<str>>$validationErrors
 }

api/src/feat/simulations/insert-simulated-failure.edgeql

@@ -7,6 +7,7 @@ export type InsertSimulatedFailureArgs = {
   readonly "response": string;
   readonly "gasUsed": bigint;
   readonly "reason": string;
+  readonly "validationErrors": ReadonlyArray<string>;
 };
 
 export type InsertSimulatedFailureReturns = {
@@ -19,7 +20,8 @@ insert SimulatedFailure {
   transaction := <Transaction><uuid>$transaction,
   response := <Bytes>$response,
   gasUsed := <bigint>$gasUsed,
-  reason := <str>$reason
+  reason := <str>$reason,
+  validationErrors := <array<str>>$validationErrors
 }`, args);
 
 }

api/src/feat/simulations/insert-simulated-failure.query.ts

@@ -81,7 +81,7 @@ export class SimulationsWorker extends Worker<SimulationsQueue> {
     );
     if (!t) return 'Transaction not found';
 
-    const validPromise = this.isValidatable(t);
+    const validationErrorsPromise = this.getValidationErrors(t);
     const account = asUAddress(t.account.address);
     const localAccount = asAddress(account);
     const chain = asChain(account);
@@ -101,7 +101,10 @@ export class SimulationsWorker extends Worker<SimulationsQueue> {
     });
 
     const error = trace.error || trace.revertReason;
-    const result = await (!error
+    const validationErrors = await validationErrorsPromise;
+    const success = !error && !validationErrors.length;
+
+    const result = await (success
       ? this.db.exec(insertSimulatedSuccess, {
           transaction: t.id,
           response: trace.output,
@@ -111,16 +114,16 @@ export class SimulationsWorker extends Worker<SimulationsQueue> {
           transaction: t.id,
           response: trace.output,
           gasUsed: trace.gasUsed,
-          reason: error,
+          reason: error ?? '',
+          validationErrors,
         }));
 
     const logs = await this.simulateEvents(t);
     await this.events.processSimulatedAndOptimistic({ chain, logs, result: asUUID(result.id) });
 
     this.proposals.event({ id: asUUID(t.id), account }, ProposalEvent.simulated);
 
-    const valid = await validPromise;
-    return { executable: valid && !error };
+    return { executable: success };
   }
 
   private async simulateEvents(t: TransactionExecutableShape) {
@@ -252,12 +255,14 @@ export class SimulationsWorker extends Worker<SimulationsQueue> {
     return logs;
   }
 
-  private async isValidatable(t: TransactionExecutableShape) {
-    if (!t.policy.isActive) return false;
-    if (t.validationErrors.length) return false;
+  private async getValidationErrors(t: TransactionExecutableShape) {
+    const errors: string[] = [];
+
+    if (!t.policy.isActive) errors.push('Policy not active');
+    if (t.validationErrors.length) errors.push('Policy validation errors');
 
     const approved = t.policy.threshold <= t.approvals.length;
-    if (!approved) return false;
+    if (!approved) errors.push('Insufficient approval');
 
     // Check all limits
     const transfers = transactionAsTx(t)
@@ -282,7 +287,10 @@ export class SimulationsWorker extends Worker<SimulationsQueue> {
       }),
     );
 
-    return limitResults.every((r) => r);
+    const sufficientSpending = limitResults.every((r) => r);
+    if (!sufficientSpending) errors.push('Greater than allowed spending');
+
+    return errors;
   }
 
   async bootstrap() {