refactor: move rate limiter to zetaclient and add metrics

changelog.md

@@ -57,6 +57,7 @@
 * [2013](https://github.com/zeta-chain/node/pull/2013) - rename `GasPriceVoter` message to `VoteGasPrice`
 * [2059](https://github.com/zeta-chain/node/pull/2059) - Remove unused params from all functions in zetanode
 * [2076](https://github.com/zeta-chain/node/pull/2076) - automatically deposit native zeta to an address if it doesn't exist on ZEVM.
+* [2110](https://github.com/zeta-chain/node/pull/2110) - move non-query rate limiter logic to zetaclient side and code refactor.
 * [2071](https://github.com/zeta-chain/node/pull/2071) - Modify chains struct to add all chain related information
 
 ### Features

cmd/zetae2e/local/local.go

@@ -313,6 +313,7 @@ func localE2ETest(cmd *cobra.Command, _ []string) {
 			e2etests.TestUpdateBytecodeZRC20Name,
 			e2etests.TestUpdateBytecodeConnectorName,
 			e2etests.TestDepositEtherLiquidityCapName,
+			e2etests.TestRateLimiterName,
 
 			// TestMigrateChainSupportName tests EVM chain migration. Currently this test doesn't work with Anvil because pre-EIP1559 txs are not supported
 			// See issue below for details

docs/openapi/openapi.swagger.yaml

@@ -27223,6 +27223,32 @@ paths:
             $ref: '#/definitions/googlerpcStatus'
       tags:
         - Query
+  /zeta-chain/crosschain/rateLimiterInput:
+    get:
+      summary: Queries the input data of rate limiter.
+      operationId: Query_RateLimiterInput
+      responses:
+        "200":
+          description: A successful response.
+          schema:
+            $ref: '#/definitions/crosschainQueryRateLimiterInputResponse'
+        default:
+          description: An unexpected error response.
+          schema:
+            $ref: '#/definitions/googlerpcStatus'
+      parameters:
+        - name: limit
+          in: query
+          required: false
+          type: integer
+          format: int64
+        - name: window
+          in: query
+          required: false
+          type: string
+          format: int64
+      tags:
+        - Query
   /zeta-chain/crosschain/zetaAccounting:
     get:
       operationId: Query_ZetaAccounting
@@ -54077,6 +54103,32 @@ definitions:
     properties:
       rateLimiterFlags:
         $ref: '#/definitions/crosschainRateLimiterFlags'
+  crosschainQueryRateLimiterInputResponse:
+    type: object
+    properties:
+      height:
+        type: string
+        format: int64
+      cctxs_missed:
+        type: array
+        items:
+          type: object
+          $ref: '#/definitions/crosschainCrossChainTx'
+      cctxs_pending:
+        type: array
+        items:
+          type: object
+          $ref: '#/definitions/crosschainCrossChainTx'
+      total_pending:
+        type: string
+        format: uint64
+      past_cctxs_value:
+        type: string
+      pending_cctxs_value:
+        type: string
+      lowest_pending_cctx_height:
+        type: string
+        format: int64
   crosschainQueryZetaAccountingResponse:
     type: object
     properties:

pkg/math/float.go

@@ -0,0 +1,23 @@
+package math
+
+import (
+	"math/big"
+)
+
+// Percentage calculates the percentage of A over B.
+func Percentage(a, b *big.Int) *big.Float {
+	// if a is zero, return nil to avoid division by zero
+	if b.Cmp(big.NewInt(0)) == 0 {
+		return nil
+	}
+
+	// convert a and a to big.Float
+	floatA := new(big.Float).SetInt(a)
+	floatB := new(big.Float).SetInt(b)
+
+	// calculate the percentage of a over b
+	percentage := new(big.Float).Quo(floatA, floatB)
+	percentage.Mul(percentage, big.NewFloat(100))
+
+	return percentage
+}

pkg/math/float_test.go

@@ -0,0 +1,54 @@
+package math
+
+import (
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPercentage(t *testing.T) {
+	testCases := []struct {
+		name        string
+		numerator   *big.Int
+		denominator *big.Int
+		percentage  *big.Float
+		fail        bool
+	}{
+		{
+			name:        "positive percentage",
+			numerator:   big.NewInt(165),
+			denominator: big.NewInt(1000),
+			percentage:  big.NewFloat(16.5),
+			fail:        false,
+		},
+		{
+			name:        "negative percentage",
+			numerator:   big.NewInt(-165),
+			denominator: big.NewInt(1000),
+			percentage:  big.NewFloat(-16.5),
+			fail:        false,
+		},
+		{
+			name:        "zero denominator",
+			numerator:   big.NewInt(1),
+			denominator: big.NewInt(0),
+			percentage:  nil,
+			fail:        true,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			percentage := Percentage(tc.numerator, tc.denominator)
+			fmt.Printf("percentage: %v\n", percentage)
+			if tc.fail {
+				require.Nil(t, percentage)
+			} else {
+				require.True(t, percentage.Cmp(tc.percentage) == 0)
+			}
+		})
+	}
+}

proto/crosschain/query.proto

@@ -117,6 +117,11 @@ service Query {
   rpc RateLimiterFlags(QueryRateLimiterFlagsRequest) returns (QueryRateLimiterFlagsResponse) {
     option (google.api.http).get = "/zeta-chain/crosschain/rateLimiterFlags";
   }
+
+  // Queries the input data of rate limiter.
+  rpc RateLimiterInput(QueryRateLimiterInputRequest) returns (QueryRateLimiterInputResponse) {
+    option (google.api.http).get = "/zeta-chain/crosschain/rateLimiterInput";
+  }
 }
 
 message QueryZetaAccountingRequest {}
@@ -263,6 +268,21 @@ message QueryListPendingCctxResponse {
   uint64 totalPending = 2;
 }
 
+message QueryRateLimiterInputRequest {
+  uint32 limit = 1;
+  int64 window = 2;
+}
+
+message QueryRateLimiterInputResponse {
+  int64 height = 1;
+  repeated CrossChainTx cctxs_missed = 2;
+  repeated CrossChainTx cctxs_pending = 3;
+  uint64 total_pending = 4;
+  string past_cctxs_value = 5;
+  string pending_cctxs_value = 6;
+  int64 lowest_pending_cctx_height = 7;
+}
+
 message QueryListPendingCctxWithinRateLimitRequest {
   uint32 limit = 1;
 }

proto/crosschain/rate_limiter_flags.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 package zetachain.zetacore.crosschain;
 
 import "gogoproto/gogo.proto";
+import "pkg/coin/coin.proto";
 
 option go_package = "github.com/zeta-chain/zetacore/x/crosschain/types";
 
@@ -28,3 +29,14 @@ message Conversion {
     (gogoproto.nullable) = false
   ];
 }
+
+message AssetRate {
+  int64 chainId = 1;
+  string asset = 2;
+  uint32 decimals = 3;
+  coin.CoinType coin_type = 4;
+  string rate = 5 [
+    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
+    (gogoproto.nullable) = false
+  ];
+}

testutil/sample/crosschain.go

@@ -3,6 +3,7 @@ package sample
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"math/rand"
 	"testing"
 
@@ -49,6 +50,18 @@ func RateLimiterFlags() types.RateLimiterFlags {
 	}
 }
 
+func AssetRate() *types.AssetRate {
+	r := Rand()
+
+	return &types.AssetRate{
+		ChainId:  r.Int63(),
+		Asset:    EthAddress().Hex(),
+		Decimals: uint32(r.Uint64()),
+		CoinType: coin.CoinType_ERC20,
+		Rate:     sdk.NewDec(r.Int63()),
+	}
+}
+
 func OutTxTracker(t *testing.T, index string) types.OutTxTracker {
 	r := newRandFromStringSeed(t, index)
 
@@ -173,6 +186,33 @@ func CrossChainTx(t *testing.T, index string) *types.CrossChainTx {
 	}
 }
 
+// CustomCctxsInBlockRange create 1 cctx per block in block range [lowBlock, highBlock] (inclusive)
+func CustomCctxsInBlockRange(
+	t *testing.T,
+	lowBlock uint64,
+	highBlock uint64,
+	chainID int64,
+	coinType coin.CoinType,
+	asset string,
+	amount uint64,
+	status types.CctxStatus,
+) (cctxs []*types.CrossChainTx) {
+	// create 1 cctx per block
+	for i := lowBlock; i <= highBlock; i++ {
+		nonce := i - 1
+		cctx := CrossChainTx(t, fmt.Sprintf("%d-%d", chainID, nonce))
+		cctx.CctxStatus.Status = status
+		cctx.InboundTxParams.CoinType = coinType
+		cctx.InboundTxParams.Asset = asset
+		cctx.InboundTxParams.InboundTxObservedExternalHeight = i
+		cctx.GetCurrentOutTxParam().ReceiverChainId = chainID
+		cctx.GetCurrentOutTxParam().Amount = sdk.NewUint(amount)
+		cctx.GetCurrentOutTxParam().OutboundTxTssNonce = nonce
+		cctxs = append(cctxs, cctx)
+	}
+	return cctxs
+}
+
 func LastBlockHeight(t *testing.T, index string) *types.LastBlockHeight {
 	r := newRandFromStringSeed(t, index)
 

typescript/crosschain/query_pb.d.ts

@@ -871,6 +871,89 @@ export declare class QueryListPendingCctxResponse extends Message<QueryListPendi
   static equals(a: QueryListPendingCctxResponse | PlainMessage<QueryListPendingCctxResponse> | undefined, b: QueryListPendingCctxResponse | PlainMessage<QueryListPendingCctxResponse> | undefined): boolean;
 }
 
+/**
+ * @generated from message zetachain.zetacore.crosschain.QueryRateLimiterInputRequest
+ */
+export declare class QueryRateLimiterInputRequest extends Message<QueryRateLimiterInputRequest> {
+  /**
+   * @generated from field: uint32 limit = 1;
+   */
+  limit: number;
+
+  /**
+   * @generated from field: int64 window = 2;
+   */
+  window: bigint;
+
+  constructor(data?: PartialMessage<QueryRateLimiterInputRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "zetachain.zetacore.crosschain.QueryRateLimiterInputRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryRateLimiterInputRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryRateLimiterInputRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryRateLimiterInputRequest;
+
+  static equals(a: QueryRateLimiterInputRequest | PlainMessage<QueryRateLimiterInputRequest> | undefined, b: QueryRateLimiterInputRequest | PlainMessage<QueryRateLimiterInputRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message zetachain.zetacore.crosschain.QueryRateLimiterInputResponse
+ */
+export declare class QueryRateLimiterInputResponse extends Message<QueryRateLimiterInputResponse> {
+  /**
+   * @generated from field: int64 height = 1;
+   */
+  height: bigint;
+
+  /**
+   * @generated from field: repeated zetachain.zetacore.crosschain.CrossChainTx cctxs_missed = 2;
+   */
+  cctxsMissed: CrossChainTx[];
+
+  /**
+   * @generated from field: repeated zetachain.zetacore.crosschain.CrossChainTx cctxs_pending = 3;
+   */
+  cctxsPending: CrossChainTx[];
+
+  /**
+   * @generated from field: uint64 total_pending = 4;
+   */
+  totalPending: bigint;
+
+  /**
+   * @generated from field: string past_cctxs_value = 5;
+   */
+  pastCctxsValue: string;
+
+  /**
+   * @generated from field: string pending_cctxs_value = 6;
+   */
+  pendingCctxsValue: string;
+
+  /**
+   * @generated from field: int64 lowest_pending_cctx_height = 7;
+   */
+  lowestPendingCctxHeight: bigint;
+
+  constructor(data?: PartialMessage<QueryRateLimiterInputResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "zetachain.zetacore.crosschain.QueryRateLimiterInputResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryRateLimiterInputResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryRateLimiterInputResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryRateLimiterInputResponse;
+
+  static equals(a: QueryRateLimiterInputResponse | PlainMessage<QueryRateLimiterInputResponse> | undefined, b: QueryRateLimiterInputResponse | PlainMessage<QueryRateLimiterInputResponse> | undefined): boolean;
+}
+
 /**
  * @generated from message zetachain.zetacore.crosschain.QueryListPendingCctxWithinRateLimitRequest
  */