Handle Gas for TRON Transactions

import { DynamicTronWalletClient, type TronTransaction } from '@dynamic-labs-wallet/node-tron';

const client = new DynamicTronWalletClient({
  environmentId: process.env.DYNAMIC_ENVIRONMENT_ID!,
});
await client.authenticateApiToken(process.env.DYNAMIC_AUTH_TOKEN!);

// For example https://api.trongrid.io (mainnet) or https://nile.trongrid.io (Nile)
const TRON_NODE = process.env.TRON_NODE!;

// Load the walletMetadata saved from createWalletAccount. The by-address lookups
// (getWalletByAddress) omit the backup info that signing needs.
const sponsorWallet = { walletMetadata: JSON.parse(process.env.SPONSOR_WALLET_METADATA!) };
const sponsorAddress = sponsorWallet.walletMetadata.accountAddress;

// In your request handler: the user's address from your frontend. Untrusted input.
const userAddress = req.body.userAddress;
if (typeof userAddress !== 'string' || !/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(userAddress)) {
  throw new Error('userAddress must be a base58 TRON address');
}

// TronGrid reads its API key from the TRON-PRO-API-KEY header.
const tronHeaders: Record<string, string> = {
  'Content-Type': 'application/json',
  ...(process.env.TRONGRID_API_KEY ? { 'TRON-PRO-API-KEY': process.env.TRONGRID_API_KEY } : {}),
};

// POST to a full-node HTTP API endpoint and return the parsed JSON response.
const tronPost = async (path: string, body: Record<string, unknown>) => {
  const response = await fetch(`${TRON_NODE}${path}`, {
    method: 'POST',
    headers: tronHeaders,
    body: JSON.stringify(body),
  });
  if (!response.ok) {
    throw new Error(`${path} returned HTTP ${response.status}`);
  }
  return response.json();
};

const signAndBroadcast = async (unsignedTransaction: TronTransaction & { Error?: string }) => {
  if (unsignedTransaction.Error) {
    throw new Error(`Full node rejected the request: ${unsignedTransaction.Error}`);
  }

  const signedTransaction = await client.signTransaction({
    walletMetadata: sponsorWallet.walletMetadata,
    password: process.env.SPONSOR_WALLET_PASSWORD!,
    transaction: unsignedTransaction,
  });

  const response = await fetch(`${TRON_NODE}/wallet/broadcasttransaction`, {
    method: 'POST',
    headers: tronHeaders,
    body: signedTransaction, // already a JSON string
  });

  const result = await response.json();
  if (!result.result) {
    throw new Error(`Broadcast failed: ${JSON.stringify(result)}`);
  }
  return result;
};

// Poll until the transaction is in a block (about 3 seconds). The node returns {} until then.
const waitForConfirmation = async (txid: string) => {
  for (let attempt = 0; attempt < 20; attempt++) {
    const info = await tronPost('/wallet/gettransactioninfobyid', { value: txid });
    if (info.id) {
      return info;
    }
    await new Promise((resolve) => setTimeout(resolve, 3000));
  }
  throw new Error(`Transaction ${txid} was not confirmed`);
};

const stakeTransaction = await tronPost('/wallet/freezebalancev2', {
  owner_address: sponsorAddress,
  frozen_balance: 6_500_000_000, // 6,500 TRX in SUN: use your own sizing
  resource: 'ENERGY',
  visible: true,
});
await signAndBroadcast(stakeTransaction);

const account = await tronPost('/wallet/getaccount', { address: userAddress, visible: true });

if (!account.address) {
  const createTransaction = await tronPost('/wallet/createaccount', {
    owner_address: sponsorAddress,
    account_address: userAddress,
    visible: true,
  });
  const { txid } = await signAndBroadcast(createTransaction);
  await waitForConfirmation(txid);
}

const ENERGY_PER_TRANSFER = 65_000; // estimate yours as described in step 3

const { TotalEnergyLimit, TotalEnergyWeight } = await tronPost('/wallet/getaccountresource', {
  address: sponsorAddress,
  visible: true,
});
const delegateSun = Math.ceil((ENERGY_PER_TRANSFER * TotalEnergyWeight) / TotalEnergyLimit) * 1_000_000;

const { max_size: maxSun = 0 } = await tronPost('/wallet/getcandelegatedmaxsize', {
  owner_address: sponsorAddress,
  type: 1, // ENERGY
  visible: true,
});

if (maxSun < delegateSun) {
  throw new Error('Not enough free stake: reclaim from other users (step 6) or stake more TRX');
}

const delegateTransaction = await tronPost('/wallet/delegateresource', {
  owner_address: sponsorAddress,
  receiver_address: userAddress,
  balance: delegateSun, // staked TRX in SUN, not Energy units
  resource: 'ENERGY',
  lock: false,
  visible: true,
});
const { txid: delegateTxid } = await signAndBroadcast(delegateTransaction);
await waitForConfirmation(delegateTxid);

import { getDefaultClient } from '@dynamic-labs-sdk/client';

const requestSponsorship = async (userAddress: string) => {
  const response = await fetch('/api/sponsor', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${getDefaultClient().token}`,
    },
    body: JSON.stringify({ userAddress }),
  });
  if (!response.ok) {
    throw new Error(`Sponsorship failed: ${await response.text()}`);
  }
};

import { getTronWeb, isTronWalletAccount } from '@dynamic-labs-sdk/tron';
import { getPrimaryWalletAccount } from '@dynamic-labs-sdk/client';

const USDT_CONTRACT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';

// amount is in the token's base units: USDT has 6 decimals, so 1 USDT is '1000000'
const sendGaslessTransfer = async (recipient: string, amount: string) => {
  const walletAccount = getPrimaryWalletAccount();

  if (!walletAccount || !isTronWalletAccount(walletAccount)) {
    return;
  }

  await requestSponsorship(walletAccount.address);

  const tronWeb = await getTronWeb({ walletAccount });

  const { transaction } = await tronWeb.transactionBuilder.triggerSmartContract(
    USDT_CONTRACT,
    'transfer(address,uint256)',
    { feeLimit: 100_000_000 }, // 100 TRX in SUN: covers the Energy with headroom; a cap, not a charge
    [
      { type: 'address', value: recipient },
      { type: 'uint256', value: amount },
    ],
    walletAccount.address,
  );

  const signedTransaction = await tronWeb.trx.sign(transaction);
  return tronWeb.trx.sendRawTransaction(signedTransaction);
};

const { delegatedResource = [] } = await tronPost('/wallet/getdelegatedresourcev2', {
  fromAddress: sponsorAddress,
  toAddress: userAddress,
  visible: true,
});
const delegatedSun = delegatedResource.reduce(
  (sum: number, resource: { frozen_balance_for_energy?: number }) => sum + (resource.frozen_balance_for_energy ?? 0),
  0,
);

const undelegateTransaction = await tronPost('/wallet/undelegateresource', {
  owner_address: sponsorAddress,
  receiver_address: userAddress,
  balance: delegatedSun,
  resource: 'ENERGY',
  visible: true,
});
await signAndBroadcast(undelegateTransaction);