Merge branch 'main' into pb/aws-kms-v5

Signed-off-by: Prithvish Baidya <[email protected]>

Author: d4mr

.github/workflows/check-build.yml

@@ -0,0 +1,24 @@
+name: Check Build
+
+on: pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.ref }}
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18"
+          cache: "yarn"
+  
+      - name: Install dependencies
+        run: yarn install
+
+      - name: Run build
+        run: yarn build

README.md

@@ -33,7 +33,7 @@ Engine is an open-source, backend HTTP server that provides a production-ready i
 - 700+ transactions sent onchain per second (can fill up an EVM block!)
 - Managed backend wallets (local, KMS)
 - Contract calls and deployments ([all EVM blockchains](https://thirdweb.com/chainlist) + private subnets)
-- Gas optimizations with retries
+- Gas-optimized retries, gas ceilings, and timeouts
 - Smart account support with session tokens
 - Gasless transactions with relayers
 - Wallet and contract webhooks

package.json

@@ -16,7 +16,8 @@
     "generate:sdk": "npx tsx ./src/scripts/generate-sdk && cd ./sdk && yarn build",
     "prisma:setup:dev": "npx tsx ./src/scripts/setup-db.ts",
     "prisma:setup:prod": "npx tsx ./dist/scripts/setup-db.js",
-    "start": "yarn prisma:setup:prod && yarn start:run",
+    "start": "yarn prisma:setup:prod && yarn start:migrations && yarn start:run",
+    "start:migrations": "npx tsx ./dist/scripts/apply-migrations.js",
     "start:run": "node --experimental-specifier-resolution=node ./dist/index.js",
     "start:docker": "docker compose --profile engine --env-file ./.env up --remove-orphans",
     "start:docker-force-build": "docker compose --profile engine --env-file ./.env up --remove-orphans --build",

src/db/transactions/db.ts

@@ -1,7 +1,6 @@
 import superjson from "superjson";
-import { env } from "../../utils/env";
-import { redis } from "../../utils/redis/redis";
-import { AnyTransaction } from "../../utils/transaction/types";
+import { MAX_REDIS_BATCH_SIZE, redis } from "../../utils/redis/redis";
+import type { AnyTransaction } from "../../utils/transaction/types";
 
 /**
  * Schemas
@@ -111,13 +110,9 @@ export class TransactionDB {
     }
 
     const result: AnyTransaction[] = [];
-    for (
-      let i = 0;
-      i < queueIds.length;
-      i += env.__EXPERIMENTAL_REDIS_BATCH_SIZE
-    ) {
+    for (let i = 0; i < queueIds.length; i += MAX_REDIS_BATCH_SIZE) {
       const keys = queueIds
-        .slice(i, i + env.__EXPERIMENTAL_REDIS_BATCH_SIZE)
+        .slice(i, i + MAX_REDIS_BATCH_SIZE)
         .map(this.transactionDetailsKey);
       const vals = await redis.mget(...keys);
 
@@ -141,13 +136,9 @@ export class TransactionDB {
     }
 
     let numDeleted = 0;
-    for (
-      let i = 0;
-      i < queueIds.length;
-      i += env.__EXPERIMENTAL_REDIS_BATCH_SIZE
-    ) {
+    for (let i = 0; i < queueIds.length; i += MAX_REDIS_BATCH_SIZE) {
       const keys = queueIds
-        .slice(i, i + env.__EXPERIMENTAL_REDIS_BATCH_SIZE)
+        .slice(i, i + MAX_REDIS_BATCH_SIZE)
         .map(this.transactionDetailsKey);
       numDeleted += await redis.unlink(...keys);
     }

src/db/transactions/queueTx.ts

@@ -1,9 +1,11 @@
 import type { DeployTransaction, Transaction } from "@thirdweb-dev/sdk";
-import { ERC4337EthersSigner } from "@thirdweb-dev/wallets/dist/declarations/src/evm/connectors/smart-wallet/lib/erc4337-signer";
-import { Address, ZERO_ADDRESS } from "thirdweb";
+import type { ERC4337EthersSigner } from "@thirdweb-dev/wallets/dist/declarations/src/evm/connectors/smart-wallet/lib/erc4337-signer";
+import { ZERO_ADDRESS, type Address } from "thirdweb";
 import type { ContractExtension } from "../../schema/extension";
+import { parseTransactionOverrides } from "../../server/utils/transactionOverrides";
 import { maybeBigInt, normalizeAddress } from "../../utils/primitiveTypes";
 import { insertTransaction } from "../../utils/transaction/insertTransaction";
+import type { InsertedTransaction } from "../../utils/transaction/types";
 
 interface QueueTxParams {
   // we should move away from Transaction type (v4 SDK)
@@ -49,10 +51,8 @@ export const queueTx = async ({
     functionName,
     functionArgs,
     extension,
-    gas: maybeBigInt(txOverrides?.gas),
-    maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
-    maxPriorityFeePerGas: maybeBigInt(txOverrides?.maxPriorityFeePerGas),
-  };
+    ...parseTransactionOverrides(txOverrides),
+  } satisfies Partial<InsertedTransaction>;
 
   // TODO: We need a much safer way of detecting if the transaction should be a user operation
   const isUserOp = !!(tx.getSigner as ERC4337EthersSigner).erc4337provider;
@@ -76,27 +76,25 @@ export const queueTx = async ({
       idempotencyKey,
       shouldSimulate: simulateTx,
     });
-  } else {
-    const isPublishedContractDeploy =
-      tx.getTarget() === ZERO_ADDRESS &&
-      functionName === "deploy" &&
-      extension === "deploy-published";
+  }
 
-    const queueId = await insertTransaction({
-      insertedTransaction: {
-        ...baseTransaction,
-        isUserOp: false,
-        deployedContractAddress,
-        deployedContractType,
-        from: normalizeAddress(await tx.getSignerAddress()),
-        to: normalizeAddress(
-          isPublishedContractDeploy ? undefined : tx.getTarget(),
-        ),
-      },
-      idempotencyKey,
-      shouldSimulate: simulateTx,
-    });
+  const isPublishedContractDeploy =
+    tx.getTarget() === ZERO_ADDRESS &&
+    functionName === "deploy" &&
+    extension === "deploy-published";
 
-    return queueId;
-  }
+  return await insertTransaction({
+    insertedTransaction: {
+      ...baseTransaction,
+      isUserOp: false,
+      deployedContractAddress,
+      deployedContractType,
+      from: normalizeAddress(await tx.getSignerAddress()),
+      to: normalizeAddress(
+        isPublishedContractDeploy ? undefined : tx.getTarget(),
+      ),
+    },
+    idempotencyKey,
+    shouldSimulate: simulateTx,
+  });
 };

src/db/wallets/walletNonce.ts

@@ -1,8 +1,8 @@
 import {
-  Address,
   eth_getTransactionCount,
   getAddress,
   getRpcClient,
+  type Address,
 } from "thirdweb";
 import { getChain } from "../../utils/chain";
 import { logger } from "../../utils/logger";
@@ -37,7 +37,7 @@ export const getUsedBackendWallets = async (
   return keys.map((key) => {
     const tokens = key.split(":");
     return {
-      chainId: parseInt(tokens[1]),
+      chainId: Number.parseInt(tokens[1]),
       walletAddress: getAddress(tokens[2]),
     };
   });
@@ -61,7 +61,7 @@ export const lastUsedNonceKey = (chainId: number, walletAddress: Address) =>
 export const splitLastUsedNonceKey = (key: string) => {
   const _splittedKeys = key.split(":");
   const walletAddress = normalizeAddress(_splittedKeys[2]);
-  const chainId = parseInt(_splittedKeys[1]);
+  const chainId = Number.parseInt(_splittedKeys[1]);
   return { walletAddress, chainId };
 };
 
@@ -87,7 +87,7 @@ export const sentNoncesKey = (chainId: number, walletAddress: Address) =>
 export const splitSentNoncesKey = (key: string) => {
   const _splittedKeys = key.split(":");
   const walletAddress = normalizeAddress(_splittedKeys[2]);
-  const chainId = parseInt(_splittedKeys[1]);
+  const chainId = Number.parseInt(_splittedKeys[1]);
   return { walletAddress, chainId };
 };
 
@@ -166,7 +166,7 @@ export const acquireNonce = async (args: {
     nonce,
     queueId,
   });
-  return { nonce, isRecycledNonce: false };
+  return { nonce, isRecycledNonce };
 };
 
 /**
@@ -181,7 +181,7 @@ export const recycleNonce = async (
   walletAddress: Address,
   nonce: number,
 ) => {
-  if (isNaN(nonce)) {
+  if (Number.isNaN(nonce)) {
     logger({
       level: "warn",
       message: `[recycleNonce] Invalid nonce: ${nonce}`,
@@ -209,7 +209,7 @@ const _acquireRecycledNonce = async (
   if (result.length === 0) {
     return null;
   }
-  return parseInt(result[0]);
+  return Number.parseInt(result[0]);
 };
 
 /**
@@ -246,7 +246,7 @@ export const syncLatestNonceFromOnchain = async (
 export const inspectNonce = async (chainId: number, walletAddress: Address) => {
   const key = lastUsedNonceKey(chainId, walletAddress);
   const nonce = await redis.get(key);
-  return nonce ? parseInt(nonce) : 0;
+  return nonce ? Number.parseInt(nonce) : 0;
 };
 
 /**

src/scripts/apply-migrations.ts

@@ -0,0 +1,69 @@
+import { logger } from "../utils/logger";
+import { acquireLock, releaseLock, waitForLock } from "../utils/redis/lock";
+import { redis } from "../utils/redis/redis";
+
+const MIGRATION_LOCK_TTL_SECONDS = 60;
+
+const main = async () => {
+  // Acquire a lock to allow only one host to run migrations.
+  // Other hosts block until the migration is completed or lock times out.
+  const acquiredLock = await acquireLock(
+    "lock:apply-migrations",
+    MIGRATION_LOCK_TTL_SECONDS,
+  );
+  if (!acquiredLock) {
+    logger({
+      level: "info",
+      message: "Migration in progress. Waiting for the lock to release...",
+      service: "server",
+    });
+    await waitForLock("lock:apply-migrations");
+    process.exit(0);
+  }
+
+  try {
+    await migrateRecycledNonces();
+
+    logger({
+      level: "info",
+      message: "Completed migrations successfully.",
+      service: "server",
+    });
+  } catch (e) {
+    logger({
+      level: "error",
+      message: `Failed to complete migrations: ${e}`,
+      service: "server",
+    });
+    process.exit(1);
+  } finally {
+    await releaseLock("lock:apply-migrations");
+  }
+
+  process.exit(0);
+};
+
+const migrateRecycledNonces = async () => {
+  const keys = await redis.keys("nonce-recycled:*");
+
+  // For each `nonce-recycled:*` key that is a "set" in Redis,
+  // migrate all members to a sorted set with score == nonce.
+  for (const key of keys) {
+    const type = await redis.type(key);
+    if (type !== "set") {
+      continue;
+    }
+
+    const members = await redis.smembers(key);
+    await redis.del(key);
+    if (members.length > 0) {
+      const args = members.flatMap((member) => {
+        const score = Number.parseInt(member);
+        return Number.isNaN(score) ? [] : [score, member];
+      });
+      await redis.zadd(key, ...args);
+    }
+  }
+};
+
+main();

src/server/index.ts

@@ -50,13 +50,23 @@ export const initServer = async () => {
     };
   }
 
+  // env.TRUST_PROXY is used to determine if the X-Forwarded-For header should be trusted.
+  // This option is force enabled for cloud-hosted Engines.
+  // See: https://fastify.dev/docs/latest/Reference/Server/#trustproxy
+  const trustProxy = env.TRUST_PROXY || !!env.ENGINE_TIER;
+  if (trustProxy) {
+    logger({
+      service: "server",
+      level: "info",
+      message: "Server is enabled with trustProxy.",
+    });
+  }
+
   // Start the server with middleware.
   const server: FastifyInstance = fastify({
     connectionTimeout: SERVER_CONNECTION_TIMEOUT,
     disableRequestLogging: true,
-    // env.TRUST_PROXY is used to determine if the X-Forwarded-For header should be trusted.
-    // See: https://fastify.dev/docs/latest/Reference/Server/#trustproxy
-    trustProxy: env.TRUST_PROXY,
+    trustProxy,
     ...(env.ENABLE_HTTPS ? httpsObject : {}),
   }).withTypeProvider<TypeBoxTypeProvider>();
 
@@ -97,7 +107,7 @@ export const initServer = async () => {
         logger({
           service: "server",
           level: "fatal",
-          message: `Failed to start server`,
+          message: "Failed to start server",
           error: err,
         });
         process.exit(1);