Merge pull request #287 from zallo-labs/Z-341-responsive-transaction

Z 341 responsive transaction

Author: hbriese

.yarn/cache/react-call-npm-1.0.1-63e43b1cc0-3732e7f1d4.zip

@@ -47,11 +47,10 @@ const NonEmptyStr: $.scalarTypeWithConstructor<_std.$str, never> = $.makeType<$.
 export type $TransactionStatus = {
   "Pending": $.$expr_Literal<$TransactionStatus>;
   "Scheduled": $.$expr_Literal<$TransactionStatus>;
-  "Executing": $.$expr_Literal<$TransactionStatus>;
   "Successful": $.$expr_Literal<$TransactionStatus>;
   "Failed": $.$expr_Literal<$TransactionStatus>;
   "Cancelled": $.$expr_Literal<$TransactionStatus>;
-} & $.EnumType<"default::TransactionStatus", ["Pending", "Scheduled", "Executing", "Successful", "Failed", "Cancelled"]>;
+} & $.EnumType<"default::TransactionStatus", ["Pending", "Scheduled", "Successful", "Failed", "Cancelled"]>;
 const TransactionStatus: $TransactionStatus = $.makeType<$TransactionStatus>(_.spec, "d2eb5a82-5489-11ef-a64b-c5eeac9d34b6", _.syntax.literal);
 
 export type $UAddress = $.ScalarType<"std::str", string>;

api/dbschema/edgeql-js/__spec__.ts

@@ -10,9 +10,7 @@ module default {
       default := true;
       rewrite insert, update using (exists __subject__.result);
     };
-    required confirmed: bool {
-      # rewrite insert, update using ((__subject__.result is Confirmed) ?? true);
-    }
+    required confirmed: bool; # rewrite insert, update using ((__subject__.result is Confirmed) ?? true);
 
     access policy members_can_select
       allow select

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

@@ -284,7 +284,7 @@ export namespace $default {
     "executable": boolean;
     "status": TransactionStatus;
   }
-  export type TransactionStatus = "Pending" | "Scheduled" | "Executing" | "Successful" | "Failed" | "Cancelled";
+  export type TransactionStatus = "Pending" | "Scheduled" | "Successful" | "Failed" | "Cancelled";
   export interface Transferlike extends Event {
     "tokenAddress": string;
     "token"?: Token | null;

api/dbschema/events.esdl

@@ -0,0 +1,18 @@
+CREATE MIGRATION m174x3tft7rqwxzekegp7qad4qlscof7tojfcmw4wielhp7h4mqsya
+    ONTO m17qamgbzvrq5axhdxhdn526i3wz42l5yt3fjdgog73ihlovmrb2sq
+{
+  ALTER TYPE default::Result {
+      ALTER TRIGGER update_tx_result WHEN (((__new__.timestamp >= __new__.transaction.result.timestamp) ?? true));
+  };
+  ALTER TYPE default::Transaction {
+      ALTER PROPERTY status {
+          USING (WITH
+              result := 
+                  .result
+          SELECT
+              std::assert_exists((default::TransactionStatus.Pending IF (((result IS default::SimulatedSuccess) OR (result IS default::SimulatedFailure)) ?? true) ELSE (default::TransactionStatus.Successful IF (((result IS default::OptimisticSuccess) OR (result IS default::ConfirmedSuccess)) ?? false) ELSE (default::TransactionStatus.Failed IF (result IS default::ConfirmedFailure) ELSE (default::TransactionStatus.Scheduled IF NOT (result[IS default::Scheduled].cancelled) ELSE default::TransactionStatus.Cancelled)))))
+          );
+      };
+  };
+  ALTER SCALAR TYPE default::TransactionStatus EXTENDING enum<Pending, Scheduled, Successful, Failed, Cancelled>;
+};

api/dbschema/interfaces.ts

@@ -11,7 +11,7 @@ module default {
     required activation: decimal { constraint min_value(0); default := 0; }
   }
 
-  scalar type TransactionStatus extending enum<'Pending', 'Scheduled', 'Executing', 'Successful', 'Failed', 'Cancelled'>;
+  scalar type TransactionStatus extending enum<'Pending', 'Scheduled', 'Successful', 'Failed', 'Cancelled'>;
 
   type Transaction extending Proposal {
     required multi unorderedOperations: Operation {
@@ -37,8 +37,7 @@ module default {
       with result := .result
       select assert_exists((
         TransactionStatus.Pending if ((result is SimulatedSuccess or result is SimulatedFailure) ?? true) else
-        TransactionStatus.Executing if (result is OptimisticSuccess) else
-        TransactionStatus.Successful if (result is ConfirmedSuccess) else
+        TransactionStatus.Successful if ((result is OptimisticSuccess or result is ConfirmedSuccess) ?? false) else
         TransactionStatus.Failed if (result is ConfirmedFailure) else
         TransactionStatus.Scheduled if (not result[is Scheduled].cancelled) else
         TransactionStatus.Cancelled # result is Scheduled
@@ -81,7 +80,8 @@ module default {
     multi link events := .<result[is Event];
     multi link transfers := .events[is Transfer];
 
-    trigger update_tx_result after insert for each do (
+    trigger update_tx_result after insert for each
+    when ((__new__.timestamp >= __new__.transaction.result.timestamp) ?? true) do (
       update __new__.transaction set { result := __new__ } 
     );
   }

api/dbschema/migrations/00005-m174x3t.edgeql

@@ -173,7 +173,7 @@ interface Confirmed implements Node & Result {
   id: ID!
   networkEthFee: Decimal!
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -188,7 +188,7 @@ type ConfirmedFailure implements Confirmed & Failure & Node & Result {
   networkEthFee: Decimal!
   reason: String
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -202,7 +202,7 @@ type ConfirmedSuccess implements Confirmed & Node & Result & Success {
   id: ID!
   networkEthFee: Decimal!
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -282,10 +282,20 @@ input EstimateFeesPerGasInput {
   feeToken: UAddress!
 }
 
+type EstimatedFeeParts {
+  maxFeePerGas: Decimal!
+  maxPriorityFeePerGas: Decimal!
+  networkFee: Decimal!
+  paymasterFees: PaymasterFees!
+  total: Decimal!
+}
+
 type EstimatedTransactionFees implements CustomNode {
+  eth: EstimatedFeeParts!
+  feeToken: EstimatedFeeParts!
+  gasLimit: Uint256!
+  gasPerPubdataLimit: Uint256!
   id: ID!
-  maxNetworkEthFee: Decimal!
-  paymasterEthFees: PaymasterFees!
 }
 
 interface Event implements Node {
@@ -311,7 +321,7 @@ interface Failure implements Node & Result {
   id: ID!
   reason: String
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -423,7 +433,7 @@ type OptimisticSuccess implements Node & Result & Success {
   gasUsed: BigInt!
   id: ID!
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -705,7 +715,7 @@ interface Result implements Node {
   gasUsed: BigInt!
   id: ID!
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -718,7 +728,7 @@ type Scheduled implements Node & Result {
   id: ID!
   response: Bytes!
   scheduledFor: DateTime!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -733,7 +743,7 @@ type SimulatedFailure implements Failure & Node & Result {
   id: ID!
   reason: String
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -746,7 +756,7 @@ type SimulatedSuccess implements Node & Result & Success {
   id: ID!
   reason: String
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -771,7 +781,7 @@ interface Success implements Node & Result {
   gasUsed: BigInt!
   id: ID!
   response: Bytes!
-  systemTx: SystemTx
+  systx: SystemTx
   timestamp: DateTime!
   transaction: Transaction!
   transfers: [Transfer!]!
@@ -901,7 +911,6 @@ type TransactionPreparation implements CustomNode {
 
 enum TransactionStatus {
   Cancelled
-  Executing
   Failed
   Pending
   Scheduled

api/dbschema/transaction.esdl

@@ -1,13 +1,10 @@
 import { Global, Module } from '@nestjs/common';
 import { NetworksHealthIndicator } from './networks.health';
 import { NetworksService } from './networks.service';
-import { registerBullQueue } from '../bull/bull.util';
-import { NetworkQueue, NetworkWorker } from './networks.worker';
 
 @Global()
 @Module({
-  imports: [...registerBullQueue(NetworkQueue)],
   exports: [NetworksService, NetworksHealthIndicator],
-  providers: [NetworksService, NetworksHealthIndicator, NetworkWorker],
+  providers: [NetworksService, NetworksHealthIndicator],
 })
 export class NetworksModule {}

api/schema.graphql

@@ -30,6 +30,7 @@ import { runExclusively } from '~/util/mutex';
 import { ETH } from 'lib/dapps';
 import { fromPromise } from 'neverthrow';
 import { PartialK } from '~/util/types';
+import Decimal from 'decimal.js';
 
 export type Network = ReturnType<typeof create>;
 
@@ -90,7 +91,8 @@ function create({ chainKey, redis }: CreateParams) {
     ...eip712WalletActions()(client),
     ...walletActions(client, transport, redis),
     ...blockDetails(client),
-    ...estimatedFeesPerGas(client, redis),
+    feeParams: feeParams(client, redis),
+    maxFeePerGas: maxFeePerGas(client, redis),
     sendAccountTransaction: sendAccountTransaction(client, redis),
     traceCall: traceCall(client),
   }));
@@ -163,41 +165,48 @@ function blockDetails(client: Client) {
   };
 }
 
-export function estimatedFeesPerGasKey(chain: Chain) {
-  return `estimatedFeesPerGasKey:${chain}`;
+export interface NetworkFeeParams {
+  maxFeePerGas: Decimal;
+  maxPriorityFeePerGas: Decimal;
+  gasPerPubdataLimit: bigint;
 }
 
-async function getEstimatedFeesPerGas(client: Client, redis: Redis): Promise<FeeValuesEIP1559> {
-  const cached = await redis.get(estimatedFeesPerGasKey(client.chain.key));
-  if (cached) {
-    const p = JSON.parse(cached) as any;
-    return {
-      maxFeePerGas: BigInt(p.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(p.maxPriorityFeePerGas),
-    } satisfies FeeValuesEIP1559;
-  }
-
-  const r = await client.estimateFeesPerGas();
-  if (r.maxFeePerGas === undefined || r.maxPriorityFeePerGas === undefined)
-    throw new Error('Gas price estimates non EIP-1559');
-
-  return r;
-}
-
-function estimatedFeesPerGas(client: Client, redis: Redis) {
-  const estimatedFeesPerGas = async () => {
-    const v = await getEstimatedFeesPerGas(client, redis);
+function feeParams(client: Client, redis: Redis) {
+  const { estimateFee } = publicActionsL2()(client);
+
+  return async (): Promise<NetworkFeeParams> => {
+    const r = await (async () => {
+      const key = `feeParams:${client.chain.key}`;
+      const cached = await redis.get(key);
+      if (cached) {
+        const p = JSON.parse(cached) as any;
+        return {
+          maxFeePerGas: BigInt(p.maxFeePerGas),
+          maxPriorityFeePerGas: BigInt(p.maxPriorityFeePerGas),
+          gasPerPubdataLimit: p.gasPerPubdataLimit,
+        };
+      }
+
+      const fresh = await estimateFee({
+        /* estimateFee required to get gasPerPubdataLimit */
+        account: '0x1111111111111111111111111111111111111111',
+        to: '0x1111111111111111111111111111111111111111',
+      });
+      redis.set(key, JSON.stringify(fresh), 'EX', 5);
+      return fresh;
+    })();
 
     return {
-      maxFeePerGas: asDecimal(v.maxFeePerGas!, ETH),
-      maxPriorityFeePerGas: asDecimal(v.maxPriorityFeePerGas!, ETH),
+      maxFeePerGas: asDecimal(r.maxFeePerGas, ETH),
+      maxPriorityFeePerGas: asDecimal(r.maxPriorityFeePerGas, ETH),
+      gasPerPubdataLimit: r.gasPerPubdataLimit,
     };
   };
+}
 
-  return {
-    estimatedFeesPerGas,
-    estimatedMaxFeePerGas: async () => (await estimatedFeesPerGas()).maxFeePerGas,
-  };
+function maxFeePerGas(client: Client, redis: Redis) {
+  const getFeeParams = feeParams(client, redis);
+  return async () => (await getFeeParams()).maxFeePerGas;
 }
 
 export type TransactionWithDetailedOutput = {
@@ -229,14 +238,10 @@ export type SendAccountTransactionReturn = ReturnType<ReturnType<typeof sendAcco
 function sendAccountTransaction(client: Client, redis: Redis) {
   // Transactions must be submitted sequentially due to requirement for incrementing nonces
   return async (tx: SendAccountTransactionParams) => {
-    const feesPerGas = await getEstimatedFeesPerGas(client, redis);
-
     return await runExclusively(
       async () => {
         const serialized = client.chain.serializers.transaction({
           chainId: client.chain.id,
-          maxFeePerGas: feesPerGas.maxFeePerGas!,
-          maxPriorityFeePerGas: feesPerGas.maxPriorityFeePerGas!,
           nonce: await client.getTransactionCount({ address: tx.from }),
           ...tx,
         });
@@ -302,6 +307,7 @@ export interface TraceCallParams {
   block?: TraceCallSchema['Parameters'][1];
   options?: TraceCallSchema['Parameters'][2];
 }
+export type TraceCallReturnType = Awaited<ReturnType<ReturnType<typeof traceCall>>>;
 
 function traceCall(client: Client) {
   return async (params: TraceCallParams) => {