blockchain-utils-service 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "blockchain-utils-service",
+  "version": "1.0.0",
+  "description": "A lightweight service for deploying contracts, writing transactions, reading events, and checking block numbers.",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "echo 'No build needed'",
+    "test": "echo 'No test yet'"
+  },
+  "keywords": [
+    "thirdweb",
+    "blockchain",
+    "smart-contracts",
+    "events",
+    "deploy",
+    "transactions"
+  ],
+  "author": "Mai Labs",
+  "license": "MIT",
+  "dependencies": {
+    "@thirdweb-dev/sdk": "^4.0.99",
+    "axios": "^1.6.7",
+    "dotenv": "^16.3.0",
+    "ethers": "^5.8.0",
+    "thirdweb": "^5.104.1",
+    "undici": "^7.8.0"
+  }
+}

package/src/contractSubscribeWebhook.js

@@ -0,0 +1,88 @@
+// src/contractSubscribeWebhook.js
+
+// #pending
+// Add check webhook URL function!
+/**
+ * Subscribes to smart contract events and sets up a webhook for notifications.
+ *
+ * @param {Object} config - Subscription configuration.
+ * @param {string} config.name - A name for the webhook subscription.
+ * @param {number|string} config.chainId - The chain ID of the blockchain network (e.g., 137 for Polygon).
+ * @param {string} config.contractAddress - The address of the deployed smart contract.
+ * @param {string} config.thirdwebInsightUrl - The base URL for the Thirdweb Insight API.
+ * @param {string[]} config.eventsSignature - An array of event signatures to listen for (e.g., ["Transfer(address,address,uint256)"]).
+ * @param {string} config.secretKey -  Secret key for authenticating with the Thirdweb Insight.
+ * @param {string} config.abi - The contract's ABI (Application Binary Interface), required to decode events.
+ * @param {string} config.webhookUrl - The URL where event notifications will be sent.
+ * @param {string} config.environment - The Development Environment.
+ * @param {string} config.subscriptionType - The type of webhook e.g. "activityType" or "eventType"
+ * @returns {Promise<Object>} - Result of the webhook subscription, typically includes subscription ID or status.
+ */
+export async function contractSubscribeWebhook({
+  chainId,
+  contractAddress,
+  inhouseStreamUrl,
+  eventsSignature,
+  webhookUrl,
+  environment,
+  subscriptionType
+}) {
+  try {
+    const uri = `${inhouseStreamUrl}/streams/evm`;
+    const body = {
+      chainId,
+      contractAddress,
+      eventsSignature,
+      webhookUrl,
+      environment,
+      subscriptionType
+    };
+    const headers = {
+      "Content-Type": "application/json",
+    };
+    const response = await fetch(uri, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify(body),
+    });
+    const result = await response.json();
+    if (!response.ok) {
+      throw new Error(`Failed - Webhook Creation for contract: ${JSON.stringify(result)}`);
+    }
+    return { isSuccess: true, data: { webhookResponse: result } };
+  } catch (error) {
+    console.log(error)
+    return { isSuccess: false, data: `Webhook creation failed: ${JSON.stringify(error.message)}` };
+  }
+}
+
+// #pending
+/**
+ * Updates a Thirdweb Insight Webhook status.
+ *
+ * @param {string} webhookId – The ID of the webhook to be updated.
+ * @param {boolean} disabledFlag – The new status for the webhook, either "true" (to disable) or "false" (to enable).
+ * @param {string} inhouseStreamUrl - The base URL for the Thirdweb Insight API.
+ * @returns {Promise<{isSuccess: boolean, data: any}>}
+ */
+export async function updateWebhookStatus({ streamId, status, inhouseStreamUrl }) {
+  if (!streamId || !inhouseStreamUrl || !status) {
+    return { isSuccess: false, data: "Missing required parameters" };
+  }
+  try {
+    const uri = `${inhouseStreamUrl}/streams/evm/${streamId}/status`;
+    const body = { status };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const response = await fetch(uri, { method: "POST", headers, body: JSON.stringify(body) });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`UpdateWebhookStatus Failed: ${errorData}`);
+    }
+    const result = await response.json();
+    return { isSuccess: true, data: result };
+  } catch (error) {
+    return { isSuccess: false, data: JSON.stringify(error) };
+  }
+}

package/src/deploy.js

@@ -0,0 +1,73 @@
+// src/deployNew.js
+
+import { createThirdwebClient } from "thirdweb";
+import { deployContract } from "thirdweb/deploys";
+import { engineAccount } from "thirdweb/wallets/engine";
+
+/**
+ * Deploys a new smart contract using the provided configuration.
+ *
+ * @param {Object} config - Deployment configuration.
+ * @param {string} config.secretKey - The Thirdweb Engine API secret key.
+ * @param {string} config.abi - The ABI (Application Binary Interface) of the contract.
+ * @param {string} config.bytecode - The compiled bytecode of the contract.
+ * @param {object} config.constructorArgs - Constructor arguments required by the contract (e.g., name, symbol, owner).
+ * @param {object} config.chain - The Thirdweb chain configuration object (e.g., `80002`).
+ * @param {string} config.engineUrl - The thirdweb engine url
+ * @param {string} config.backendWalletAddress - The deployer address
+ * @param {string} config.authorizationToken - The thirdweb auth key
+ * @returns {Promise<string>} - The address of the deployed contract.
+ */
+export async function deployNewContract({
+  secretKey,
+  abi,
+  bytecode,
+  constructorArgs,
+  chain,
+  engineUrl,
+  backendWalletAddress,
+  authorizationToken,
+}) {
+  try {
+    if (!secretKey || !abi || !bytecode || !chain || !engineUrl || !backendWalletAddress || !authorizationToken) {
+      throw new Error("Missing required parameters for deployNewContract");
+    }
+    const client = createThirdwebClient({ secretKey });
+
+    const engineAcc = engineAccount({
+      engineUrl: engineUrl,
+      authToken: authorizationToken,
+      walletAddress: backendWalletAddress,
+    });
+
+    const constructorAbi = abi.find(item => item.type === "constructor");
+    if (!constructorAbi) {
+      const deployedAddress = await deployContract({
+        client,
+        account: engineAcc,
+        chain,
+        abi,
+        bytecode,
+        constructorParams: {}, // Empty if no constructor
+      });
+      return { deployedAddress };
+    }
+
+    const constructorParams = {};
+    constructorAbi.inputs.forEach((input, index) => {
+      constructorParams[input.name] = constructorArgs[index];
+    });
+
+    const deployedAddress = await deployContract({
+      client,
+      account: engineAcc,
+      chain,
+      abi,
+      bytecode,
+      constructorParams,
+    });
+    return { deployedAddress };
+  } catch (err) {
+    throw new Error(`Failed to deploy contract: ${err.message}`);
+  }
+}

package/src/getBalance.js

@@ -0,0 +1,34 @@
+// Function to check the balance of a blockchain address
+/**
+ * Check the balance of a blockchain address through a Thirdweb Engine backend.
+ *
+ * @param {Object} config
+ * @param {string} config.address - Address to check balance for
+ * @param {number|string} config.chainId - Chain ID (eg. 80002 for Amoy)
+ * @param {string} config.engineUrl - Base URL of your Engine backend (eg. 'https://your-engine.com')
+ * @param {string} config.authorizationToken - Bearer token for Engine access
+ * @returns {Promise<object>} - Result containing balance in Wei and Eth
+ */
+
+// #Review Pending
+export const checkBalance = async ({ address, chainId, engineUrl, authorizationToken }) => {
+  try {
+    const url = `${engineUrl}/backend-wallet/${chainId}/${address}/get-balance`
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authorizationToken}`,
+    };
+    const response = await fetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`${JSON.stringify(errorData)}`);
+    }
+    const { result } = await response.json();
+    const balanceInWei = result.value.toString();
+    const balanceInEth = result.displayValue;
+
+    return { balanceInWei, balanceInEth }
+  } catch (error) {
+    throw new Error(`failed in checkBalance : ${error}`);
+  }
+}

package/src/getBlockNumberReached.js

@@ -0,0 +1,34 @@
+// src/getBlockNumberReached.js
+
+import { getRpcClient, eth_blockNumber } from 'thirdweb/rpc';
+import { createThirdwebClient } from 'thirdweb';
+import { defineChain } from 'thirdweb/chains';
+/**
+ * Checks whether the current block number on the blockchain has reached or surpassed a specified target block number.
+ *
+ * @param {Object} config - Configuration for the block check.
+ * @param {string} config.chainId - The ChainId
+ * @param {string} config.clientId - The Thirdweb API clientId used for authentication (if required).
+ * @param {number} config.targetBlockNumber - The target block number to compare against.
+ * @returns {Promise<boolean>} - Returns `true` if the current block number is greater than or equal to the target, otherwise `false`.
+ */
+export async function hasBlockNumberReached({
+  chainId,
+  clientId,
+  targetBlockNumber,
+}) {
+  try {
+    if (!chainId || !clientId || targetBlockNumber === undefined) {
+      throw new Error("Missing required parameters for hasBlockNumberReached");
+    }
+    const chain = defineChain(Number(chainId));
+    const client = createThirdwebClient({
+      clientId: clientId,
+    });
+    const rpcRequest = getRpcClient({ client, chain });
+    const currentBlock = await eth_blockNumber(rpcRequest);
+    return currentBlock >= targetBlockNumber;
+  } catch (err) {
+    throw new Error(`Failed to check block number reached: ${err.message}`);
+  }
+}

package/src/getCreatorTxHash.js

@@ -0,0 +1,25 @@
+/**
+ * Finds the deployment transaction hash for a given smart contract address on a specific blockchain.
+ *
+ * @param {string} contractAddress - The address of the deployed smart contract.
+ * @param {number|string} chainId - The chain ID of the blockchain network (e.g., 1 for Ethereum Mainnet, 137 for Polygon).
+ * @param {string} etherscanAPI - The API key for Etherscan or an Etherscan-compatible explorer used to query transactions.
+ * @returns {Promise<string|null>} - The transaction hash of the contract deployment, or `null` if not found.
+ */
+export async function findDeploymentTxHash(contractAddress, chainId, etherscanAPI) {
+  try {
+    const apiUrl = `https://api.etherscan.io/v2/api?chainid=${chainId}&module=contract&action=getcontractcreation&contractaddresses=${contractAddress}&apikey=${etherscanAPI}`;
+    const response = await fetch(apiUrl);
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`Failed to fetch contract creation info: ${JSON.stringify(errorData)}`);
+    }
+    const { result, status } = await response.json();
+    if (status != '1' || result.length === 0) {
+      throw new Error("Failed to retrieve hash!");
+    }
+    return { isSuccess: true, data: { txHash: result[0].txHash, blockNumber: result[0].blockNumber } };
+  } catch (err) {
+    return { isSuccess: false, data: err.message }
+  }
+}

package/src/getEvents.js

@@ -0,0 +1,67 @@
+// src/getEvents.js
+import axios from "axios";
+import https from "https";
+
+/**
+ * Fetch events from a Thirdweb Engine backend between specific blocks.
+ *
+ * @param {Object} config
+ * @param {string} config.thirdwebInsightUrl - Thirdweb Insight base URL (eg. https://insight.thirdweb.com/v1)
+ * @param {number|string} config.chainId - Chain ID (eg. 80002 for Amoy)
+ * @param {string} config.contractAddress - Smart contract address
+ * @param {string} config.eventName - Name of the event to fetch
+ * @param {number|string} config.fromBlock - Starting block number
+ * @param {number|string} [config.toBlock] - Ending block number (default: 'latest')
+ * @param {object} [config.filters] - Optional filters object
+ * @param {string} config.clientId - Thirdweb Insight Client Id
+ * @param {number} config.limit - Number of events to fetch per page
+ * @param {number} config.page - Page number for pagination
+ * @returns {Promise<object>} - Events response
+ */
+export async function fetchContractEvents({
+  thirdwebInsightUrl,
+  chainId,
+  contractAddress,
+  eventSignature,
+  fromBlock,
+  toBlock = "latest",
+  filters = {},
+  clientId,
+  limit,
+  page,
+}) {
+  if (
+    thirdwebInsightUrl == null ||
+    chainId == null ||
+    contractAddress == null ||
+    eventSignature == null ||
+    fromBlock == null ||
+    toBlock == null ||
+    clientId == null ||
+    limit == null ||
+    page == null
+  ) {
+    throw new Error("Missing required parameters for fetchContractEvents");
+  }
+  const agent = new https.Agent({
+    rejectUnauthorized: false,
+  });
+  const url = `${thirdwebInsightUrl}/events/${contractAddress}/${eventSignature}`;
+  const params = {
+    chain_id: chainId,
+    filter_block_number_gte: fromBlock,
+    filter_block_number_lte: toBlock,
+    sort_order: "asc",
+    limit: limit,
+    page: page,
+  };
+  const headers = {
+    "x-client-id": clientId,
+  };
+  try {
+    const response = await axios.get(url, { params, headers });
+    return response.data;
+  } catch (error) {
+    throw new Error(`Failed to fetch events: ${error.response?.data?.error || error.message}`);
+  }
+}

package/src/getTokenLatestPrice.js

@@ -0,0 +1,33 @@
+/**
+ * Finds the deployment transaction hash for a given smart contract address on a specific blockchain.
+ *
+ * @param {string} contractAddress - The address of the deployed smart contract.
+ * @param {number|string} chainId - The chain ID of the blockchain network (e.g., 1 for Ethereum Mainnet, 137 for Polygon).
+ * @param {string} apiKey - The API key Moralis
+ * @returns {Promise<object|null>} - Returns { tokenName, tokenSymbol, usdPrice }.
+ */
+export async function fetchTokenLatestPrice({ contractAddress, chainId, apiKey }) {
+  try {
+    if (!contractAddress || !chainId || !apiKey) {
+      throw new Error("Missing required parameters for fetchTokenLatestPrice");
+    }
+    const hexChainId = '0x' + chainId.toString(16);
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+    };
+    const apiUrl = `https://deep-index.moralis.io/api/v2.2/erc20/${contractAddress}/price?chain=${hexChainId}&include=percent_change`;
+    const response = await fetch(apiUrl, {
+      method: 'GET',
+      headers: headers
+    });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`Fetching price failed: ${JSON.stringify(errorData)}`);
+    }
+    const { usdPrice, tokenName, tokenSymbol } = await response.json();
+    return { tokenName, tokenSymbol, usdPrice };
+  } catch (err) {
+    throw new Error(`Failed to fetch latest price for ${contractAddress} at ${chainId} : ${err.message}`);
+  }
+}

package/src/getTokenPrice.js

@@ -0,0 +1,46 @@
+// src/getTokenPrice.js
+
+import { createThirdwebClient, getContract, readContract } from 'thirdweb';
+import { defineChain } from 'thirdweb/chains';
+
+/**
+ * Fetches the latest token price from a Chainlink oracle on the specified blockchain.
+ *
+ * @param {Object} params - Parameters for retrieving the token price.
+ * @param {string} params.chainlinkOracleAddress - The address of the Chainlink price feed oracle contract.
+ * @param {number} params.chainlinkOracleChainId - The chain ID of the blockchain where the oracle contract is deployed.
+ * @param {string} params.clientId - The Thirdweb client ID used for authenticated RPC requests.
+ * @returns {Promise<string>} - Returns the latest token price as a string.
+ */
+export async function getTokenPrice({
+  chainlinkOracleAddress,
+  chainlinkOracleChainId,
+  clientId
+}) {
+  try {
+    if (!(chainlinkOracleAddress && chainlinkOracleChainId)) {
+      throw new Error("Missing required parameters for getTokenPrice");
+    }
+    const client = createThirdwebClient({ clientId: clientId });
+    const chain = defineChain(Number(chainlinkOracleChainId));
+    const contract = getContract({
+      client,
+      chain: chain,
+      address: chainlinkOracleAddress,
+    });
+    const decimals = Number(await readContract({
+      contract,
+      method: "function decimals() view returns (uint8)",
+      params: [],
+    }));
+    const latestPrice = Number(await readContract({
+      contract,
+      method: "function latestAnswer() view returns (int256)",
+      params: [],
+    }));
+    const priceInUsd = latestPrice / Math.pow(10, decimals);
+    return priceInUsd;
+  } catch (err) {
+    throw new Error(`Failed getting token price ${err.message}`);
+  }
+}

package/src/getTransactionHash.js

@@ -0,0 +1,45 @@
+/**
+ * Retrieve the transaction hash from Thirdweb Engine using the queueId.
+ * Retries until the transactionHash is available or max attempts are reached.
+ *
+ * @param {string} queueId - The queue ID returned after submitting the transaction
+ * @param {string} authorizationToken - Bearer token to authorize the request
+ * @param {string} engineUrl - Base URL of the Thirdweb Engine
+ * @param {number} [maxAttempts=10] - Maximum number of retry attempts
+ * @param {number} [delayMs=3000] - Delay in milliseconds between attempts
+ * @returns {Promise<Object>} - TransactionHash if available
+ */
+export async function getTransactionHash({ queueId, engineUrl, authorizationToken, maxAttempts = 10, delayMs = 3000 }) {
+  if (!queueId || !authorizationToken || !engineUrl) {
+    throw new Error("Missing required parameters for getTransactionHash");
+  }
+  const writeUrl = `${engineUrl}/transaction/status/${queueId}`;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(writeUrl, {
+        method: "GET",
+        headers: {
+          accept: "application/json",
+          Authorization: `Bearer ${authorizationToken}`,
+        },
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const result = await response.json();
+      if (result.result?.transactionHash) {
+        return result.result.transactionHash;
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      } else {
+        throw new Error("Transaction hash not available after maximum retries.");
+      }
+    } catch (error) {
+      if (attempt === maxAttempts) {
+        throw new Error("Failed to fetch transaction hash after multiple attempts.");
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,12 @@
+export { deployNewContract } from "./deploy.js";
+export { writeTransaction } from "./writeTransaction.js";
+export { fetchContractEvents } from "./getEvents.js";
+export { hasBlockNumberReached } from "./getBlockNumberReached.js";
+export { contractSubscribeWebhook, updateWebhookStatus } from "./contractSubscribeWebhook.js";
+export { getTransactionHash } from "./getTransactionHash.js";
+export { fetchTokenLatestPrice } from "./getTokenLatestPrice.js";
+export { getTokenPrice } from "./getTokenPrice.js";
+export { findDeploymentTxHash } from "./getCreatorTxHash.js";
+export { readTransaction } from "./readTransaction.js";
+export { checkBalance } from "./getBalance.js";
+export { transferFunds } from "./transfer.js";

package/src/readTransaction.js

@@ -0,0 +1,36 @@
+// src/readTransaction.js
+
+/**
+ * Reads data from a smart contract using Thirdweb SDK.
+ *
+ * @param {Object} config
+ * @param {string} config.engineUrl - Base URL of your Engine backend (eg. 'https://your-engine.com')
+ * @param {number|string} config.chainId - Chain ID (eg. 80002 for Amoy)
+ * @param {string} config.contractAddress - Smart contract address
+ * @param {string} config.functionName - Full function signature (eg. 'function mint(address,uint256)')
+ * @param {string} config.args - Function arguments
+ * @param {string} config.authorizationToken - Bearer token for Engine access
+ * @returns {Promise<object>} - Result of the read transaction
+ */
+export async function readTransaction({ engineUrl, chainId, contractAddress, functionName, args, authorizationToken }) {
+  try {
+    if (!engineUrl || !chainId || !contractAddress || !functionName || !authorizationToken) {
+      throw new Error("Missing required parameters for readTransaction");
+    }
+    const readUrl = `${engineUrl}/contract/${chainId}/${contractAddress}/read`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authorizationToken}`,
+    };
+    const url = `${readUrl}?functionName=${encodeURIComponent(functionName)}&args=${encodeURIComponent(args)}`;
+    const response = await fetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`Transaction read failed: ${JSON.stringify(errorData)}`);
+    }
+    const { result } = await response.json();
+    return result;
+  } catch (err) {
+    throw new Error(`Failed to read transaction: ${err.message}`);
+  }
+}

package/src/transfer.js

@@ -0,0 +1,46 @@
+/**
+ * Transfer funds through a Thirdweb Engine backend.
+ *
+ * @param {Object} config
+ * @param {string} config.recipient - Recipient address
+ * @param {number|string} config.chainId - Chain ID (eg. 80002 for Amoy)
+ * @param {number|string} config.amount - Amount to transfer 
+ * @param {string} config.engineUrl - Base URL of your Engine backend (eg. 'https://your-engine.com')
+ * @param {string} config.authorizationToken - Bearer token for Engine access
+ * @param {string} config.backendWalletAddress - Address of backend signer wallet
+ * @returns {Promise<object>} - Result of the transfer transaction
+ */
+
+// #Review Pending
+export const transferFunds = async ({ recipient, chainId, amount, engineUrl, authorizationToken, backendWalletAddress }) => {
+  try {
+    if ((amount) > 1) {
+      throw new Error(`More than 1 Eth not supported!`);
+    }
+
+    const url = `${engineUrl}/backend-wallet/${chainId}/transfer`
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authorizationToken}`,
+      "x-backend-wallet-address": backendWalletAddress,
+      "x-idempotency-key": `idemp-${Date.now()}`,
+    };
+    const body = JSON.stringify({
+      to: recipient,
+      currencyAddress: "0x0000000000000000000000000000000000000000",
+      amount: amount
+    });
+
+    const response = await fetch(url, { method: "POST", headers, body });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`${JSON.stringify(errorData)}`);
+    }
+    const { result } = await response.json();
+    return result
+  } catch (error) {
+    throw new Error(`Failed to transfer: ${error}`);
+
+  }
+
+}

package/src/writeTransaction.js

@@ -0,0 +1,55 @@
+// src/writeTransaction.js
+import { Agent, setGlobalDispatcher } from "undici";
+
+const agent = new Agent({
+  connect: {
+    rejectUnauthorized: false,
+  },
+});
+setGlobalDispatcher(agent);
+
+/**
+ * Write a transaction through a Thirdweb Engine backend.
+ *
+ * @param {Object} config
+ * @param {string} config.engineUrl - Base URL of your Engine backend (eg. 'https://your-engine.com')
+ * @param {number|string} config.chainId - Chain ID (eg. 80002 for Amoy)
+ * @param {string} config.contractAddress - Smart contract address
+ * @param {string} config.functionName - Full function signature (eg. 'function mint(address,uint256)')
+ * @param {Array} config.args - Function arguments
+ * @param {string} config.backendWalletAddress - Address of backend signer wallet
+ * @param {string} config.authorizationToken - Bearer token for Engine access
+ * @returns {Promise<object>} - Result of the write transaction
+ */
+export async function writeTransaction({
+  engineUrl,
+  chainId,
+  contractAddress,
+  functionName,
+  args,
+  backendWalletAddress,
+  authorizationToken,
+}) {
+  try {
+    if (!engineUrl || !chainId || !contractAddress || !functionName || !args || !backendWalletAddress || !authorizationToken) {
+      throw new Error("Missing required parameters for writeTransaction");
+    }
+    const writeUrl = `${engineUrl}/contract/${chainId}/${contractAddress}/write`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authorizationToken}`,
+      "x-backend-wallet-address": backendWalletAddress,
+      "x-idempotency-key": `idemp-${Date.now()}`,
+    };
+    const body = JSON.stringify({ functionName, args });
+    const response = await fetch(writeUrl, { method: "POST", headers, body });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`Transaction write failed: ${JSON.stringify(errorData)}`);
+    }
+    const { result } = await response.json();
+    return result;
+  } catch (err) {
+    throw new Error(`Failed to write transaction: ${err.message}`);
+  }
+}