feat: integrate Thirdweb Engine into Request Node

Author: MantisClone

packages/request-node/README.md

@@ -221,42 +221,25 @@ Default values correspond to the basic configuration used to run a server in a t
 
 #### Options:
 
-- `--port` Port for the server to listen for API requests
-  - Default value: `3000`
-  - Environment variable name: `$PORT`
-- `--networkId` Id of the Ethereum network used
-  - Default value: `0`
-  - Environment variable name: `$ETHEREUM_NETWORK_ID`
-- `--providerUrl` URL of the web3 provider for Ethereum
-  - Default value: `http://localhost:8545`
-  - Environment variable name: `$WEB3_PROVIDER_URL`
-- `--ipfsUrl` URL of the IPFS gateway
-  - Default value: `http://localhost:5001`
-  - Environment variable name: `$IPFS_URL`
-- `--ipfsTimeout` Timeout threshold to connect to the IPFS gateway
-  - Default value: `10000`
-  - Environment variable name: `$IPFS_TIMEOUT`
-- `--blockConfirmations` The number of block confirmations to consider a transaction successful
-  - Default value: `2`
-  - Environment variable name: `$BLOCK_CONFIRMATIONS`
-- `--storageConcurrency` Maximum number of concurrent calls to Ethereum or IPFS
-  - Default value: `'200'`
-  - Environment variable name: `$STORAGE_MAX_CONCURRENCY`
-- `--logLevel` The maximum level of messages we will log
-  - Environment variable name: `$LOG_LEVEL`
-  - Available levels: ERROR, WARN, INFO and DEBUG
-- `--logMode` Defines the log format to use
-  - Environment variable name: `$LOG_MODE`
-  - Available modes:
-    - `human` is a more human readable log to display during development
-    - `machine` is better for parsing on CI or deployments
-- `--persistTransactionTimeout` Defines the delay in seconds to wait before sending a timeout when creating or updating a request
-  - Default value: 600
-  - Environment variable name: `$PERSIST_TRANSACTION_TIMEOUT`
-- `--externalUrl` External url of the node (used to identified where the buffer data are stored before being broadcasted on ethereum)
-  - Environment variable name: `$EXTERNAL_URL`
-- `--graphNodeUrl` External url of the Graph node, if any. If specified, this will replace the traditional data access with the Graph implementation. Default is undefined. See [TheGraph mode](#thegraph-mode).
-  - Environment variable name: `$GRAPH_NODE_URL`
+| Option                           | Environment Variable              | Description                                                                                       | Required                             | Default Value                       |
+| -------------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------- |
+| `--port`                         | `PORT`                            | Port for the server to listen for API requests                                                    | No                                   | `3000`                              |
+| `--networkId`                    | `ETHEREUM_NETWORK_ID`             | Id of the Ethereum network used                                                                   | No                                   | `0`                                 |
+| `--providerUrl`                  | `WEB3_PROVIDER_URL`               | URL of the web3 provider for Ethereum                                                             | No                                   | `http://localhost:8545`             |
+| `--ipfsUrl`                      | `IPFS_URL`                        | URL of the IPFS gateway                                                                           | No                                   | `http://localhost:5001`             |
+| `--ipfsTimeout`                  | `IPFS_TIMEOUT`                    | Timeout threshold to connect to the IPFS gateway                                                  | No                                   | `10000`                             |
+| `--blockConfirmations`           | `BLOCK_CONFIRMATIONS`             | The number of block confirmations to consider a transaction successful                            | No                                   | `2`                                 |
+| `--storageConcurrency`           | `STORAGE_MAX_CONCURRENCY`         | Maximum number of concurrent calls to Ethereum or IPFS                                            | No                                   | `200`                               |
+| `--logLevel`                     | `LOG_LEVEL`                       | The maximum level of messages we will log (ERROR, WARN, INFO or DEBUG)                            | No                                   | `INFO`                              |
+| `--logMode`                      | `LOG_MODE`                        | The log format to use (human or machine)                                                          | No                                   | `human`                             |
+| `--persistTransactionTimeout`    | `PERSIST_TRANSACTION_TIMEOUT`     | Defines the delay in seconds to wait before sending a timeout when creating or updating a request | No                                   | `600`                               |
+| `--externalUrl`                  | `EXTERNAL_URL`                    | External url of the node (used to identify where the buffer data are stored)                      | No                                   | -                                   |
+| `--graphNodeUrl`                 | `GRAPH_NODE_URL`                  | External url of the Graph node. See [TheGraph mode](#thegraph-mode)                               | No                                   | -                                   |
+| `--thirdwebEngineUrl`            | `THIRDWEB_ENGINE_URL`             | URL of your Thirdweb Engine instance                                                              | **Yes**                              | -                                   |
+| `--thirdwebAccessToken`          | `THIRDWEB_ACCESS_TOKEN`           | Access token for Thirdweb Engine                                                                  | **Yes**                              | -                                   |
+| `--thirdwebBackendWalletAddress` | `THIRDWEB_BACKEND_WALLET_ADDRESS` | Address of the wallet configured in Thirdweb Engine                                               | **Yes**                              | -                                   |
+| `--thirdwebWebhookSecret`        | `THIRDWEB_WEBHOOK_SECRET`         | Secret for verifying webhook signatures                                                           | No                                   | -                                   |
+| -                                | `MNEMONIC`                        | The mnemonic for generating the wallet private key                                                | **Yes** (except on private networks) | `candy maple...` (only for testing) |
 
 #### Mnemonic
 
@@ -336,6 +319,25 @@ yarn start
 Open a browser and navigate towards: http://localhost:3000/status
 You can see the details of your local Request & IPFS nodes.
 
+## Thirdweb Engine Integration
+
+The Request Node uses Thirdweb Engine for transaction submission, which offers several advantages:
+
+- No need to manage private keys in the Request Node
+- Better transaction management and monitoring
+- Automated gas price optimization and retry mechanisms
+- Webhook notifications for transaction status
+
+### Setting Up Thirdweb Engine
+
+1. Deploy Thirdweb Engine by following the [official documentation](https://portal.thirdweb.com/engine/getting-started)
+2. Create a wallet in Thirdweb Engine for the Request Node
+3. Ensure the wallet has sufficient funds for gas costs
+4. Generate an access token with appropriate permissions
+5. Configure the Request Node with the required environment variables (see Options table above)
+
+**Note:** The Request Node no longer supports transaction submission through local wallets. All transactions are processed through Thirdweb Engine.
+
 ## Contributing
 
 Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

packages/request-node/src/config.ts

@@ -41,7 +41,6 @@ const defaultValues = {
     mode: LogMode.human,
   },
   server: {
-    headers: '{}',
     port: 3000,
   },
   wallet: {
@@ -51,6 +50,12 @@ const defaultValues = {
   litProtocolRPC: 'https://yellowstone-rpc.litprotocol.com',
   litProtocolCapacityCreditsUsage: '1',
   litProtocolCapacityCreditsExpirationInSeconds: 10 * 60, // 10 minutes
+  thirdweb: {
+    engineUrl: '',
+    accessToken: '',
+    backendWalletAddress: '',
+    webhookSecret: '',
+  },
 };
 
 const getOption = <T extends string | number>(
@@ -83,6 +88,42 @@ export const getLitProtocolNetwork = makeOption(
   defaultValues.litProtocolNetwork,
 );
 
+/**
+ * Get Thirdweb Engine URL from command line argument, environment variables or default values
+ */
+export const getThirdwebEngineUrl = makeOption(
+  'thirdwebEngineUrl',
+  'THIRDWEB_ENGINE_URL',
+  defaultValues.thirdweb.engineUrl,
+);
+
+/**
+ * Get Thirdweb Access Token from command line argument, environment variables or default values
+ */
+export const getThirdwebAccessToken = makeOption(
+  'thirdwebAccessToken',
+  'THIRDWEB_ACCESS_TOKEN',
+  defaultValues.thirdweb.accessToken,
+);
+
+/**
+ * Get Thirdweb Backend Wallet Address from command line argument, environment variables or default values
+ */
+export const getThirdwebBackendWalletAddress = makeOption(
+  'thirdwebBackendWalletAddress',
+  'THIRDWEB_BACKEND_WALLET_ADDRESS',
+  defaultValues.thirdweb.backendWalletAddress,
+);
+
+/**
+ * Get Thirdweb Webhook Secret from command line argument, environment variables or default values
+ */
+export const getThirdwebWebhookSecret = makeOption(
+  'thirdwebWebhookSecret',
+  'THIRDWEB_WEBHOOK_SECRET',
+  defaultValues.thirdweb.webhookSecret,
+);
+
 /**
  * Get the litProtocolNetwork from command line argument, environment variables or default values to send with the API responses
  */
@@ -240,9 +281,12 @@ export function getHelpMessage(): string {
     OPTIONS
       SERVER OPTIONS
         port (${defaultValues.server.port})\t\t\t\tPort for the server to listen for API requests
-        headers (${
-          defaultValues.server.headers
-        })\t\t\t\tCustom headers to send with the API responses
+
+      THIRDWEB ENGINE OPTIONS
+        thirdwebEngineUrl\t\t\t\tURL of your Thirdweb Engine instance (REQUIRED)
+        thirdwebAccessToken\t\t\t\tAccess token for Thirdweb Engine (REQUIRED)
+        thirdwebBackendWalletAddress\t\tAddress of the wallet configured in Thirdweb Engine (REQUIRED)
+        thirdwebWebhookSecret\t\t\tSecret for verifying webhook signatures (optional)
 
       THE GRAPH OPTIONS
         graphNodeUrl (${defaultValues.storage.thegraph.nodeUrl})\t\t\t\tURL of the Graph node
@@ -280,13 +324,13 @@ export function getHelpMessage(): string {
         logMode (${defaultValues.log.mode})\t\t\tThe node log mode (human or machine)
 
     EXAMPLE
-      yarn start --port 5000 --networkId 1
+      yarn start --port 5000 --networkId 1 --thirdwebEngineUrl=https://engine.thirdweb.io --thirdwebAccessToken=your_token --thirdwebBackendWalletAddress=0x123...
 
-  All options are optional, not specified options are read from environment variables
-  If the environment variable is not specified, default value is used
+  All options except Thirdweb Engine options are optional. Thirdweb Engine options are required and can be set via environment variables if not specified in command line.
 
   Default mnemonic is:
   ${defaultValues.wallet.mnemonic}
+  NOTE: This mnemonic should ONLY be used for testing on private networks.
 `;
 
   return message;
@@ -306,5 +350,35 @@ export const getConfigDisplay = (): string => {
   Lit Protocol RPC: ${getLitProtocolRPC()}
   Lit Protocol Capacity Credits Uses: ${getLitProtocolCapacityCreditsUsage()}
   Lit Protocol Capacity Credits Expiration in seconds: ${getLitProtocolCapacityCreditsExpirationInSeconds()}
+  Thirdweb Engine URL: ${getThirdwebEngineUrl()}
+  Thirdweb Backend Wallet: ${getThirdwebBackendWalletAddress()}
 `;
 };
+
+/**
+ * Check if all required Thirdweb configuration values are provided
+ * @throws Error if required configuration is missing
+ */
+export function validateThirdwebConfig(): void {
+  const engineUrl = getThirdwebEngineUrl();
+  const accessToken = getThirdwebAccessToken();
+  const backendWalletAddress = getThirdwebBackendWalletAddress();
+
+  if (!engineUrl) {
+    throw new Error(
+      'Thirdweb Engine URL is required. Set THIRDWEB_ENGINE_URL environment variable or use --thirdwebEngineUrl option.',
+    );
+  }
+
+  if (!accessToken) {
+    throw new Error(
+      'Thirdweb Access Token is required. Set THIRDWEB_ACCESS_TOKEN environment variable or use --thirdwebAccessToken option.',
+    );
+  }
+
+  if (!backendWalletAddress) {
+    throw new Error(
+      'Thirdweb Backend Wallet Address is required. Set THIRDWEB_BACKEND_WALLET_ADDRESS environment variable or use --thirdwebBackendWalletAddress option.',
+    );
+  }
+}

packages/request-node/src/dataAccess.ts

@@ -1,49 +1,57 @@
-import { providers, Wallet } from 'ethers';
-import { NonceManager } from '@ethersproject/experimental';
-import { CurrencyTypes, DataAccessTypes, LogTypes, StorageTypes } from '@requestnetwork/types';
-
-import * as config from './config';
 import { TheGraphDataAccess } from '@requestnetwork/thegraph-data-access';
+import { EthereumStorage, ThirdwebTransactionSubmitter } from '@requestnetwork/ethereum-storage';
 import { PendingStore } from '@requestnetwork/data-access';
-import { EthereumStorage, EthereumTransactionSubmitter } from '@requestnetwork/ethereum-storage';
+import { LogTypes, StorageTypes } from '@requestnetwork/types';
+import * as config from './config';
 
-export function getDataAccess(
-  network: CurrencyTypes.EvmChainName,
+/**
+ * Creates and returns a data access instance
+ * @param network The Ethereum network to use
+ * @param ipfsStorage The IPFS storage instance
+ * @param logger Logger instance
+ * @param graphqlUrl GraphQL endpoint URL
+ * @param blockConfirmations Number of block confirmations to wait for
+ * @returns A data access instance
+ */
+export async function getDataAccess(
+  network: string,
   ipfsStorage: StorageTypes.IIpfsStorage,
   logger: LogTypes.ILogger,
-): DataAccessTypes.IDataAccess {
-  const graphNodeUrl = config.getGraphNodeUrl();
+  graphqlUrl: string,
+  blockConfirmations: number,
+): Promise<TheGraphDataAccess> {
+  // Validate that all required Thirdweb config options are set
+  config.validateThirdwebConfig();
 
-  const wallet = Wallet.fromMnemonic(config.getMnemonic()).connect(
-    new providers.StaticJsonRpcProvider(config.getStorageWeb3ProviderUrl()),
-  );
+  logger.info('Using Thirdweb Engine for transaction submission');
 
-  const signer = new NonceManager(wallet);
-
-  const gasPriceMin = config.getGasPriceMin();
-  const gasPriceMax = config.getGasPriceMax();
-  const gasPriceMultiplier = config.getGasPriceMultiplier();
-  const blockConfirmations = config.getBlockConfirmations();
-  const txSubmitter = new EthereumTransactionSubmitter({
+  // Create ThirdwebTransactionSubmitter
+  const txSubmitter = new ThirdwebTransactionSubmitter({
+    engineUrl: config.getThirdwebEngineUrl(),
+    accessToken: config.getThirdwebAccessToken(),
+    backendWalletAddress: config.getThirdwebBackendWalletAddress(),
     network,
     logger,
-    gasPriceMin,
-    gasPriceMax,
-    gasPriceMultiplier,
-    signer,
   });
-  const pendingStore = new PendingStore();
+
+  // Initialize the transaction submitter
+  await txSubmitter.initialize();
+
+  // Create Ethereum Storage with the transaction submitter
   const storage = new EthereumStorage({
     ipfsStorage,
     txSubmitter,
-    logger,
     blockConfirmations,
+    logger,
   });
+
+  // Create and return TheGraphDataAccess
   return new TheGraphDataAccess({
-    graphql: { url: graphNodeUrl },
+    graphql: {
+      url: graphqlUrl,
+    },
     storage,
-    network,
+    pendingStore: new PendingStore(),
     logger,
-    pendingStore,
   });
 }

packages/request-node/src/server.ts

@@ -8,6 +8,7 @@ import ConfirmedTransactionStore from './request/confirmedTransactionStore';
 import { EvmChains } from '@requestnetwork/currency';
 import { getEthereumStorageNetworkNameFromId } from '@requestnetwork/ethereum-storage';
 import { SubgraphClient } from '@requestnetwork/thegraph-data-access';
+import { StorageTypes } from '@requestnetwork/types';
 
 // Initialize the node logger
 const logger = new Logger(config.getLogLevel(), config.getLogMode());
@@ -21,10 +22,32 @@ const getNetwork = () => {
   return network;
 };
 
-export const getRequestNode = (): RequestNode => {
+// Initialize the data access layer
+async function initializeDataAccess(ipfsStorage: StorageTypes.IIpfsStorage) {
+  // Get configuration values
   const network = getNetwork();
-  const storage = getDataStorage(logger);
-  const dataAccess = getDataAccess(network, storage, logger);
+  const graphqlUrl = config.getGraphNodeUrl();
+  const blockConfirmations = config.getBlockConfirmations();
+
+  // Create data access with Thirdweb transaction submitter
+  const dataAccess = await getDataAccess(
+    network,
+    ipfsStorage,
+    logger,
+    graphqlUrl,
+    blockConfirmations,
+  );
+
+  return dataAccess;
+}
+
+export const getRequestNode = async (): Promise<RequestNode> => {
+  const network = getNetwork();
+  const ipfsStorage = getDataStorage(logger);
+  await ipfsStorage.initialize();
+
+  // Use the initialized data access
+  const dataAccess = await initializeDataAccess(ipfsStorage);
 
   // we access the subgraph client directly, not through the data access,
   // because this feature is specific to RN use with Request Node. Without a node,
@@ -34,12 +57,13 @@ export const getRequestNode = (): RequestNode => {
     network,
   );
 
-  return new RequestNode(dataAccess, storage, confirmedTransactionStore, logger);
+  return new RequestNode(dataAccess, ipfsStorage, confirmedTransactionStore, logger);
 };
 
+// Main server setup
 export const startNode = async (): Promise<void> => {
   const port = config.getServerPort();
-  const requestNode = getRequestNode();
+  const requestNode = await getRequestNode();
   const server = withShutdown(
     requestNode.listen(port, () => {
       logger.info(`Listening on port ${port}`);