unused nonces

Author: arcoraven

src/db/wallets/walletNonce.ts

@@ -3,16 +3,11 @@ import { getChain } from "../../utils/chain";
 import { redis } from "../../utils/redis/redis";
 import { thirdwebClient } from "../../utils/sdk";
 
-/**
- * !IMPORTANT
- *
- * The nonce stored is the LAST USED NONCE.
- * To get the next available nonce, use `incrWalletNonce()`.
- */
-
+// Data type: String
 const lastUsedNonceKey = (chainId: number, walletAddress: Address) =>
   `nonce:${chainId}:${walletAddress}`;
 
+// Data type: Array of String
 const unusedNoncesKey = (chainId: number, walletAddress: Address) =>
   `nonce-unused:${chainId}:${walletAddress}`;
 
@@ -23,13 +18,10 @@ const unusedNoncesKey = (chainId: number, walletAddress: Address) =>
  * @param walletAddress
  * @returns number - The next unused nonce value for this wallet.
  */
-export const getAndUpdateNonce = async (
-  chainId: number,
-  walletAddress: Address,
-) => {
+export const acquireNonce = async (chainId: number, walletAddress: Address) => {
   // Acquire an unused nonce, if any.
-  let nonce = await getAndUpdateLowestUnusedNonce(chainId, walletAddress);
-  if (nonce) {
+  let nonce = await _acquireUnusedNonce(chainId, walletAddress);
+  if (nonce !== null) {
     return nonce;
   }
 
@@ -51,32 +43,29 @@ export const getAndUpdateNonce = async (
  * @param walletAddress
  * @param nonce
  */
-export const addUnusedNonce = async (
+export const releaseNonce = async (
   chainId: number,
   walletAddress: Address,
   nonce: number,
 ) => {
+  if (isNaN(nonce) || nonce < 3) {
+    throw new Error(`**** NONCE IS BAD WHY???: ${nonce}`);
+  }
+
   const key = unusedNoncesKey(chainId, walletAddress);
-  await redis.zadd(key, nonce, nonce);
+  await redis.rpush(key, nonce);
 };
 
 /**
- * Acquires the lowest unused nonce.
+ * Acquires an unused nonce.
  * @param chainId
  * @param walletAddress
  * @returns
  */
-export const getAndUpdateLowestUnusedNonce = async (
-  chainId: number,
-  walletAddress: Address,
-) => {
+const _acquireUnusedNonce = async (chainId: number, walletAddress: Address) => {
   const key = unusedNoncesKey(chainId, walletAddress);
-  const res = await redis.zpopmin(key);
-  if (res.length > 0) {
-    // res will be [value, score] where the score is the nonce.
-    return parseInt(res[1]);
-  }
-  return null;
+  const res = await redis.lpop(key);
+  return res ? parseInt(res) : null;
 };
 
 const _syncNonce = async (
@@ -106,7 +95,7 @@ const _syncNonce = async (
  * @param walletAddress
  * @returns number - The last used nonce value for this wallet.
  */
-export const getNonce = async (chainId: number, walletAddress: Address) => {
+export const inspectNonce = async (chainId: number, walletAddress: Address) => {
   const key = lastUsedNonceKey(chainId, walletAddress);
   const nonce = await redis.get(key);
   return nonce ? parseInt(nonce) : 0;
@@ -116,7 +105,10 @@ export const getNonce = async (chainId: number, walletAddress: Address) => {
  * Delete all wallet nonces. Useful when the get out of sync.
  */
 export const deleteAllNonces = async () => {
-  const keys = await redis.keys("nonce:*");
+  const keys = [
+    ...(await redis.keys("nonce:*")),
+    ...(await redis.keys("nonce-unused:*")),
+  ];
   if (keys.length > 0) {
     await redis.del(keys);
   }

src/server/routes/backend-wallet/getBalance.ts

@@ -6,13 +6,9 @@ import {
   currencyValueSchema,
   standardResponseSchema,
 } from "../../schemas/sharedApiSchemas";
-import { walletParamSchema } from "../../schemas/wallet";
+import { walletWithAddressParamSchema } from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-// INPUTS
-const requestSchema = walletParamSchema;
-
-// OUTPUT
 const responseSchema = Type.Object({
   result: Type.Object({
     walletAddress: Type.String(),
@@ -33,7 +29,7 @@ responseSchema.example = {
 
 export async function getBalance(fastify: FastifyInstance) {
   fastify.route<{
-    Params: Static<typeof requestSchema>;
+    Params: Static<typeof walletWithAddressParamSchema>;
     Reply: Static<typeof responseSchema>;
   }>({
     method: "GET",
@@ -43,7 +39,7 @@ export async function getBalance(fastify: FastifyInstance) {
       description: "Get the native balance for a backend wallet.",
       tags: ["Backend Wallet"],
       operationId: "getBalance",
-      params: requestSchema,
+      params: walletWithAddressParamSchema,
       response: {
         ...standardResponseSchema,
         [StatusCodes.OK]: responseSchema,

src/server/routes/backend-wallet/getNonce.ts

@@ -2,12 +2,12 @@ import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { Address } from "thirdweb";
-import { getNonce } from "../../../db/wallets/walletNonce";
+import { inspectNonce } from "../../../db/wallets/walletNonce";
 import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
-import { walletParamSchema } from "../../schemas/wallet";
+import { walletWithAddressParamSchema } from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-const requestSchema = walletParamSchema;
+const requestSchema = walletWithAddressParamSchema;
 
 const responseSchema = Type.Object({
   result: Type.Object({
@@ -43,7 +43,7 @@ export const getBackendWalletNonce = async (fastify: FastifyInstance) => {
     handler: async (req, reply) => {
       const { chain, walletAddress } = req.params;
       const chainId = await getChainIdFromChain(chain);
-      const nonce = await getNonce(chainId, walletAddress as Address);
+      const nonce = await inspectNonce(chainId, walletAddress as Address);
 
       reply.status(StatusCodes.OK).send({
         result: {

src/server/routes/backend-wallet/getTransactions.ts

@@ -7,10 +7,10 @@ import {
   TransactionSchema,
   toTransactionSchema,
 } from "../../schemas/transaction";
-import { walletParamSchema } from "../../schemas/wallet";
+import { walletWithAddressParamSchema } from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-const ParamsSchema = walletParamSchema;
+const ParamsSchema = walletWithAddressParamSchema;
 
 const responseBodySchema = Type.Object({
   result: Type.Object({

src/server/routes/backend-wallet/sendTransaction.ts

@@ -10,13 +10,12 @@ import {
   transactionWritesResponseSchema,
 } from "../../schemas/sharedApiSchemas";
 import { txOverridesSchema } from "../../schemas/txOverrides";
-import { walletWithAAHeaderSchema } from "../../schemas/wallet";
+import {
+  walletChainParamSchema,
+  walletWithAAHeaderSchema,
+} from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-const ParamsSchema = Type.Object({
-  chain: Type.String(),
-});
-
 const requestBodySchema = Type.Object({
   toAddress: Type.Optional(
     Type.String({
@@ -45,7 +44,7 @@ requestBodySchema.examples = [
 
 export async function sendTransaction(fastify: FastifyInstance) {
   fastify.route<{
-    Params: Static<typeof ParamsSchema>;
+    Params: Static<typeof walletChainParamSchema>;
     Body: Static<typeof requestBodySchema>;
     Reply: Static<typeof transactionWritesResponseSchema>;
     Querystring: Static<typeof requestQuerystringSchema>;
@@ -57,7 +56,7 @@ export async function sendTransaction(fastify: FastifyInstance) {
       description: "Send a transaction with transaction parameters",
       tags: ["Backend Wallet"],
       operationId: "sendTransaction",
-      params: ParamsSchema,
+      params: walletChainParamSchema,
       body: requestBodySchema,
       headers: walletWithAAHeaderSchema,
       querystring: requestQuerystringSchema,
@@ -76,8 +75,6 @@ export async function sendTransaction(fastify: FastifyInstance) {
         "x-account-address": accountAddress,
       } = request.headers as Static<typeof walletWithAAHeaderSchema>;
 
-      // Standardize
-
       const chainId = await getChainIdFromChain(chain);
 
       let queueId: string;

src/server/routes/backend-wallet/sendTransactionBatch.ts

@@ -1,14 +1,16 @@
 import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { createCustomError } from "../../middleware/error";
+import { Address, Hex } from "thirdweb";
+import { maybeBigInt } from "../../../utils/primitiveTypes";
+import { insertTransaction } from "../../../utils/transaction/insertTransaction";
 import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
 import { txOverridesWithValueSchema } from "../../schemas/txOverrides";
-import { walletHeaderSchema } from "../../schemas/wallet";
-
-const ParamsSchema = Type.Object({
-  chain: Type.String(),
-});
+import {
+  walletChainParamSchema,
+  walletHeaderSchema,
+} from "../../schemas/wallet";
+import { getChainIdFromChain } from "../../utils/chain";
 
 const requestBodySchema = Type.Array(
   Type.Object({
@@ -29,14 +31,13 @@ const requestBodySchema = Type.Array(
 
 const responseBodySchema = Type.Object({
   result: Type.Object({
-    groupId: Type.String(),
     queueIds: Type.Array(Type.String()),
   }),
 });
 
 export async function sendTransactionBatch(fastify: FastifyInstance) {
   fastify.route<{
-    Params: Static<typeof ParamsSchema>;
+    Params: Static<typeof walletChainParamSchema>;
     Body: Static<typeof requestBodySchema>;
     Reply: Static<typeof responseBodySchema>;
   }>({
@@ -48,22 +49,50 @@ export async function sendTransactionBatch(fastify: FastifyInstance) {
         "Send a batch of raw transactions with transaction parameters",
       tags: ["Backend Wallet"],
       operationId: "sendTransactionBatch",
-      params: ParamsSchema,
+      params: walletChainParamSchema,
       body: requestBodySchema,
       headers: walletHeaderSchema,
       response: {
         ...standardResponseSchema,
         [StatusCodes.OK]: responseBodySchema,
       },
-      hide: true,
-      deprecated: true,
     },
     handler: async (request, reply) => {
-      throw createCustomError(
-        "This endpoint is deprecated",
-        StatusCodes.GONE,
-        "ENDPOINT_DEPRECATED",
-      );
+      const { chain } = request.params;
+      const { "x-backend-wallet-address": fromAddress } =
+        request.headers as Static<typeof walletHeaderSchema>;
+      const chainId = await getChainIdFromChain(chain);
+
+      const transactionRequests = request.body;
+
+      const queueIds: string[] = [];
+      for (const transactionRequest of transactionRequests) {
+        const { toAddress, data, value, txOverrides } = transactionRequest;
+
+        const queueId = await insertTransaction({
+          insertedTransaction: {
+            isUserOp: false,
+            chainId,
+            from: fromAddress as Address,
+            to: toAddress as Address | undefined,
+            data: data as Hex,
+            value: BigInt(value),
+
+            gas: maybeBigInt(txOverrides?.gas),
+            maxFeePerGas: maybeBigInt(txOverrides?.maxFeePerGas),
+            maxPriorityFeePerGas: maybeBigInt(
+              txOverrides?.maxPriorityFeePerGas,
+            ),
+          },
+        });
+        queueIds.push(queueId);
+      }
+
+      reply.status(StatusCodes.OK).send({
+        result: {
+          queueIds,
+        },
+      });
     },
   });
 }

src/server/routes/backend-wallet/simulateTransaction.ts

@@ -10,17 +10,12 @@ import {
   simulateResponseSchema,
   standardResponseSchema,
 } from "../../schemas/sharedApiSchemas";
-import { walletWithAAHeaderSchema } from "../../schemas/wallet";
+import {
+  walletChainParamSchema,
+  walletWithAAHeaderSchema,
+} from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-// INPUT
-const ParamsSchema = Type.Object({
-  chain: Type.String({
-    examples: ["80002"],
-    description: "Chain ID",
-  }),
-});
-
 const simulateRequestBodySchema = Type.Object({
   toAddress: Type.String({
     description: "The contract address",
@@ -58,10 +53,9 @@ const simulateRequestBodySchema = Type.Object({
   ),
 });
 
-// LOGIC
 export async function simulateTransaction(fastify: FastifyInstance) {
   fastify.route<{
-    Params: Static<typeof ParamsSchema>;
+    Params: Static<typeof walletChainParamSchema>;
     Body: Static<typeof simulateRequestBodySchema>;
     Reply: Static<typeof simulateResponseSchema>;
   }>({
@@ -72,7 +66,7 @@ export async function simulateTransaction(fastify: FastifyInstance) {
       description: "Simulate a transaction with transaction parameters",
       tags: ["Backend Wallet"],
       operationId: "simulateTransaction",
-      params: ParamsSchema,
+      params: walletChainParamSchema,
       body: simulateRequestBodySchema,
       headers: walletWithAAHeaderSchema,
       response: {

src/server/routes/backend-wallet/transfer.ts

@@ -23,11 +23,16 @@ import {
   transactionWritesResponseSchema,
 } from "../../schemas/sharedApiSchemas";
 import { txOverridesWithValueSchema } from "../../schemas/txOverrides";
-import { walletHeaderSchema, walletParamSchema } from "../../schemas/wallet";
+import {
+  walletHeaderSchema,
+  walletWithAddressParamSchema,
+} from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
 // INPUTS
-const requestSchema = Type.Omit(walletParamSchema, ["walletAddress"]);
+const requestSchema = Type.Omit(walletWithAddressParamSchema, [
+  "walletAddress",
+]);
 const requestBodySchema = Type.Object({
   to: Type.String({
     description: "Address of the wallet to transfer to",

src/server/routes/backend-wallet/withdraw.ts

@@ -16,10 +16,13 @@ import {
   requestQuerystringSchema,
   standardResponseSchema,
 } from "../../schemas/sharedApiSchemas";
-import { walletHeaderSchema, walletParamSchema } from "../../schemas/wallet";
+import {
+  walletHeaderSchema,
+  walletWithAddressParamSchema,
+} from "../../schemas/wallet";
 import { getChainIdFromChain } from "../../utils/chain";
 
-const ParamsSchema = Type.Omit(walletParamSchema, ["walletAddress"]);
+const ParamsSchema = Type.Omit(walletWithAddressParamSchema, ["walletAddress"]);
 
 const requestBodySchema = Type.Object({
   toAddress: Type.String({