342 lines
13 KiB
JavaScript
342 lines
13 KiB
JavaScript
"use strict";
|
|
/**
|
|
* TRON blockchain integration via TronGrid.
|
|
* Read incoming TRX/TRC20 transfers and broadcast outbound transactions.
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.PG_BIGINT_MAX = void 0;
|
|
exports.parseTrc20TokenAmount = parseTrc20TokenAmount;
|
|
exports.getCurrentBlock = getCurrentBlock;
|
|
exports.getBlockTimestamp = getBlockTimestamp;
|
|
exports.getTrxTransactionsToAddress = getTrxTransactionsToAddress;
|
|
exports.getTrc20TransfersToAddress = getTrc20TransfersToAddress;
|
|
exports.sendTrx = sendTrx;
|
|
exports.sendTrc20 = sendTrc20;
|
|
exports.signTrc20Transfer = signTrc20Transfer;
|
|
exports.classifyTronBroadcastResponse = classifyTronBroadcastResponse;
|
|
exports.broadcastSignedTransaction = broadcastSignedTransaction;
|
|
exports.getTransactionStatus = getTransactionStatus;
|
|
exports.getTrxBalanceSun = getTrxBalanceSun;
|
|
exports.getTrc20BalanceRaw = getTrc20BalanceRaw;
|
|
const hdWallet_1 = require("../hdWallet");
|
|
const TRON_GRID_URL = process.env.TRON_NODE_URL || 'https://api.trongrid.io';
|
|
const TRON_API_KEY = process.env.TRON_API_KEY || '';
|
|
/** PostgreSQL signed BIGINT upper bound. */
|
|
exports.PG_BIGINT_MAX = 9223372036854775807n;
|
|
/**
|
|
* Parses a TRC20 transfer `value` from TronGrid into smallest token units.
|
|
* Rejects non-decimal strings, floats, negative values, and amounts that do not fit in PG BIGINT.
|
|
*/
|
|
function parseTrc20TokenAmount(raw) {
|
|
if (raw == null)
|
|
return null;
|
|
let digits;
|
|
if (typeof raw === 'bigint') {
|
|
digits = raw.toString();
|
|
}
|
|
else if (typeof raw === 'number') {
|
|
if (!Number.isFinite(raw) || raw <= 0 || !Number.isInteger(raw))
|
|
return null;
|
|
digits = raw.toString();
|
|
}
|
|
else if (typeof raw === 'string') {
|
|
const s = raw.trim();
|
|
if (!/^\d+$/.test(s))
|
|
return null;
|
|
digits = s;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
try {
|
|
const amount = BigInt(digits);
|
|
if (amount <= 0n || amount > exports.PG_BIGINT_MAX)
|
|
return null;
|
|
return amount;
|
|
}
|
|
catch {
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Performs an authenticated GET request to TronGrid REST API.
|
|
* @param path API path including query string (e.g. /v1/accounts/...)
|
|
* @returns Parsed JSON response body
|
|
* @throws {Error} When HTTP status is not OK
|
|
*/
|
|
async function tronFetch(path) {
|
|
const url = `${TRON_GRID_URL}${path}`;
|
|
const headers = { 'Content-Type': 'application/json' };
|
|
if (TRON_API_KEY)
|
|
headers['TRON-PRO-API-KEY'] = TRON_API_KEY;
|
|
const res = await fetch(url, { headers });
|
|
if (!res.ok)
|
|
throw new Error(`TronGrid: ${res.status}`);
|
|
return res.json();
|
|
}
|
|
/**
|
|
* Returns the current TRON block number from the node.
|
|
* @returns Latest block height
|
|
*/
|
|
async function getCurrentBlock() {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const block = await tronWeb.trx.getCurrentBlock();
|
|
return block.block_header.raw_data.number;
|
|
}
|
|
/**
|
|
* Returns the block timestamp in Unix ms for a given block height.
|
|
*/
|
|
async function getBlockTimestamp(blockNumber) {
|
|
if (!Number.isFinite(blockNumber) || blockNumber < 0)
|
|
return null;
|
|
try {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const trx = tronWeb.trx;
|
|
const block = await trx.getBlock(blockNumber);
|
|
const ts = block?.block_header?.raw_data?.timestamp;
|
|
return typeof ts === 'number' && ts > 0 ? ts : null;
|
|
}
|
|
catch {
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Normalizes a TRON address to lowercase hex for comparison (API raw_data often returns hex).
|
|
* @param address Base58 or hex TRON address
|
|
* @returns Lowercase hex without 0x prefix, or original on conversion failure
|
|
*/
|
|
function toHexAddress(address) {
|
|
if (!address)
|
|
return '';
|
|
const tw = (0, hdWallet_1.getTronWeb)();
|
|
try {
|
|
const hex = tw.address.toHex(address);
|
|
return (hex || '').toLowerCase().replace(/^0x/, '');
|
|
}
|
|
catch {
|
|
return address.toLowerCase();
|
|
}
|
|
}
|
|
/**
|
|
* Fetches confirmed incoming TRX transfers to an address since an optional timestamp.
|
|
* @param address TRON base58 deposit address
|
|
* @param minTimestamp Optional minimum block timestamp in ms (filters older txs)
|
|
* @returns Parsed incoming transactions with estimated confirmations (~3s per block)
|
|
*/
|
|
async function getTrxTransactionsToAddress(address, minTimestamp) {
|
|
const q = new URLSearchParams();
|
|
q.set('limit', '200');
|
|
q.set('only_confirmed', 'true');
|
|
q.set('only_to', 'true');
|
|
if (minTimestamp != null && minTimestamp > 0)
|
|
q.set('min_block_timestamp', String(minTimestamp));
|
|
const data = (await tronFetch(`/v1/accounts/${address}/transactions?${q.toString()}`));
|
|
const addressHex = toHexAddress(address);
|
|
const rawList = data.data || [];
|
|
const txs = [];
|
|
for (const tx of rawList) {
|
|
const contract = tx.raw_data?.contract?.[0];
|
|
const param = contract?.parameter?.value;
|
|
if (!param || param.to_address == null)
|
|
continue;
|
|
const toRaw = (param.to_address || '').trim();
|
|
const toHex = toRaw.startsWith('T')
|
|
? toHexAddress(toRaw)
|
|
: toRaw.toLowerCase().replace(/^0x/, '');
|
|
if (!toHex || !addressHex || toHex !== addressHex)
|
|
continue;
|
|
const amount = param.amount ?? 0;
|
|
const from = param.owner_address ?? '';
|
|
// block_timestamp is Unix ms; chain block number is not timestamp/3000. Use elapsed time for confirmations (~3s per block).
|
|
const confirmations = Math.max(0, Math.floor((Date.now() - tx.block_timestamp) / 3000));
|
|
txs.push({
|
|
txId: tx.txID,
|
|
from,
|
|
to: address,
|
|
amount,
|
|
block: 0,
|
|
confirmations,
|
|
});
|
|
}
|
|
if (process.env.NODE_ENV !== 'production' && rawList.length > 0 && txs.length === 0) {
|
|
const sample = rawList[0];
|
|
const c = sample.raw_data?.contract?.[0];
|
|
const p = c?.parameter?.value;
|
|
console.log('[tron] TRX: API returned', rawList.length, 'tx(s) but none matched address. Sample:', {
|
|
txID: sample.txID,
|
|
to_address_raw: p?.to_address,
|
|
addressHex,
|
|
hasRawData: !!sample.raw_data,
|
|
});
|
|
}
|
|
return txs;
|
|
}
|
|
/**
|
|
* Fetches confirmed incoming TRC20 transfers to an address for a given contract.
|
|
* @param address TRON base58 deposit address
|
|
* @param contractAddress TRC20 contract address (e.g. USDT)
|
|
* @param minTimestamp Optional minimum event timestamp in ms
|
|
* @returns Transfers where `to` matches the address, with raw token value as string
|
|
*/
|
|
async function getTrc20TransfersToAddress(address, contractAddress, minTimestamp) {
|
|
const q = new URLSearchParams();
|
|
q.set('limit', '200');
|
|
q.set('contract_address', contractAddress);
|
|
q.set('only_confirmed', 'true');
|
|
if (minTimestamp != null && minTimestamp > 0)
|
|
q.set('min_timestamp', String(minTimestamp));
|
|
const data = (await tronFetch(`/v1/accounts/${address}/transactions/trc20?${q.toString()}`));
|
|
const out = [];
|
|
for (const e of data.data || []) {
|
|
if (e.to?.toLowerCase() !== address.toLowerCase())
|
|
continue;
|
|
const amount = parseTrc20TokenAmount(e.value);
|
|
if (amount == null) {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
console.warn(`[tron] TRC20: skip invalid amount for tx=${e.transaction_id} value=${String(e.value)}`);
|
|
}
|
|
continue;
|
|
}
|
|
const confirmations = Math.max(0, Math.floor((Date.now() - e.block_timestamp) / 3000));
|
|
out.push({
|
|
txId: e.transaction_id,
|
|
from: e.from,
|
|
to: e.to,
|
|
value: amount.toString(),
|
|
block: 0,
|
|
block_timestamp: e.block_timestamp,
|
|
confirmations,
|
|
});
|
|
}
|
|
return out;
|
|
}
|
|
/**
|
|
* Sends native TRX from a hot wallet private key.
|
|
* @param fromPrivateKeyHex Sender private key in hex
|
|
* @param toAddress Recipient base58 address
|
|
* @param amountSun Amount in sun (1 TRX = 1e6 sun)
|
|
* @returns Broadcast transaction ID
|
|
* @throws {Error} When broadcast returns no txid
|
|
*/
|
|
async function sendTrx(fromPrivateKeyHex, toAddress, amountSun) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const tx = await tronWeb.transactionBuilder.sendTrx(toAddress, Number(amountSun), fromPrivateKeyHex);
|
|
const signed = await tronWeb.trx.sign(tx, fromPrivateKeyHex);
|
|
const result = await tronWeb.trx.sendRawTransaction(signed);
|
|
const txId = result.txid || result.transaction?.txID;
|
|
if (!txId)
|
|
throw new Error('Send TRX: no txid in result');
|
|
return txId;
|
|
}
|
|
/**
|
|
* Sends TRC20 tokens via contract transfer from a hot wallet.
|
|
* @param fromPrivateKeyHex Sender private key in hex
|
|
* @param contractAddress TRC20 contract address
|
|
* @param toAddress Recipient base58 address
|
|
* @param amountRaw Token amount in smallest unit (string passed to contract)
|
|
* @returns Transaction ID from broadcast result
|
|
*/
|
|
async function sendTrc20(fromPrivateKeyHex, contractAddress, toAddress, amountRaw) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const contract = await tronWeb.contract().at(contractAddress);
|
|
const result = await contract.transfer(toAddress, amountRaw.toString()).send({ from: fromPrivateKeyHex, feeLimit: 100000000 });
|
|
return result?.transaction?.txID || result?.txid || String(result);
|
|
}
|
|
/** Lets a signed payout be re-broadcast after a lost response before TRON drops it. */
|
|
const PAYOUT_EXPIRATION_EXTENSION_SECONDS = 600;
|
|
/**
|
|
* Builds and signs a TRC20 `transfer` without broadcasting it.
|
|
*/
|
|
async function signTrc20Transfer(fromPrivateKeyHex, contractAddress, toAddress, amountRaw) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const builder = tronWeb.transactionBuilder;
|
|
const trx = tronWeb.trx;
|
|
const fromRaw = tronWeb.address.fromPrivateKey(fromPrivateKeyHex.replace(/^0x/, ''));
|
|
const fromAddress = typeof fromRaw === 'string' ? fromRaw : fromRaw.base58 ?? '';
|
|
if (!fromAddress)
|
|
throw new Error('Could not derive TRON hot wallet address');
|
|
const built = await builder.triggerSmartContract(contractAddress, 'transfer(address,uint256)', { feeLimit: 100000000 }, [
|
|
{ type: 'address', value: toAddress },
|
|
{ type: 'uint256', value: amountRaw.toString() },
|
|
], fromAddress);
|
|
if (!built?.result?.result || !built.transaction) {
|
|
throw new Error('TRON node refused to build the TRC20 transfer');
|
|
}
|
|
const extended = await builder.extendExpiration(built.transaction, PAYOUT_EXPIRATION_EXTENSION_SECONDS);
|
|
const signed = await trx.sign(extended, fromPrivateKeyHex.replace(/^0x/, ''));
|
|
const expirationMs = signed.raw_data?.expiration ?? Date.now() + 60000;
|
|
return {
|
|
txId: signed.txID,
|
|
payload: JSON.stringify(signed),
|
|
expiresAt: new Date(expirationMs),
|
|
fromAddress,
|
|
};
|
|
}
|
|
function decodeTronMessage(message) {
|
|
if (!message)
|
|
return '';
|
|
if (/^[0-9a-fA-F]+$/.test(message) && message.length % 2 === 0) {
|
|
try {
|
|
return Buffer.from(message, 'hex').toString('utf8');
|
|
}
|
|
catch {
|
|
return message;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
/**
|
|
* Interprets a `sendRawTransaction` response. A response with an error code means the node
|
|
* refused the transaction (it was not accepted); DUP_TRANSACTION_ERROR means it is already known.
|
|
*/
|
|
function classifyTronBroadcastResponse(res) {
|
|
if (res?.result === true)
|
|
return { kind: 'accepted' };
|
|
const code = String(res?.code ?? 'UNKNOWN');
|
|
if (code === 'DUP_TRANSACTION_ERROR')
|
|
return { kind: 'accepted' };
|
|
return { kind: 'rejected', code, message: decodeTronMessage(res?.message) };
|
|
}
|
|
/** Broadcasts a previously signed payload. Throws only on transport errors (outcome unknown). */
|
|
async function broadcastSignedTransaction(payload) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const trx = tronWeb.trx;
|
|
const res = await trx.sendRawTransaction(JSON.parse(payload));
|
|
return classifyTronBroadcastResponse(res);
|
|
}
|
|
/** Looks a payout up by txID on the full node (includes not-yet-solidified blocks). */
|
|
async function getTransactionStatus(txId) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const trx = tronWeb.trx;
|
|
const info = await trx.getUnconfirmedTransactionInfo(txId);
|
|
if (!info || typeof info.blockNumber !== 'number')
|
|
return { kind: 'not_found' };
|
|
const current = await getCurrentBlock();
|
|
const confirmations = Math.max(0, current - info.blockNumber + 1);
|
|
const receiptResult = info.receipt?.result;
|
|
const success = info.result !== 'FAILED' && (receiptResult === undefined || receiptResult === 'SUCCESS');
|
|
return {
|
|
kind: 'mined',
|
|
success,
|
|
confirmations,
|
|
message: success ? undefined : decodeTronMessage(info.resMessage) || receiptResult || info.result,
|
|
};
|
|
}
|
|
/**
|
|
* Returns native TRX balance in sun for an address.
|
|
*/
|
|
async function getTrxBalanceSun(address) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const balance = await tronWeb.trx.getBalance(address);
|
|
return BigInt(balance ?? 0);
|
|
}
|
|
/**
|
|
* Returns TRC20 token balance in smallest units for an address.
|
|
*/
|
|
async function getTrc20BalanceRaw(address, contractAddress) {
|
|
const tronWeb = (0, hdWallet_1.getTronWeb)();
|
|
const contract = await tronWeb.contract().at(contractAddress);
|
|
const balance = await contract.balanceOf(address).call();
|
|
return BigInt(balance?.toString?.() ?? balance ?? 0);
|
|
}
|
|
//# sourceMappingURL=tronService.js.map
|