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

Z 341 responsive transaction

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

@@ -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/events.esdl

@@ -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/interfaces.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/migrations/00005-m174x3t.edgeql

@@ -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/transaction.esdl

@@ -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/schema.graphql

@@ -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/src/core/networks/networks.module.ts

@@ -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/src/core/networks/networks.service.ts

@@ -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) => {