@shapeshiftoss/unchained-client 10.14.7-alpha.1 → 10.14.8

package/dist/cjs/generated/thorchain/apis/ProxyApi.d.ts

@@ -14,6 +14,14 @@ import * as runtime from '../runtime';
  *
  */
 export declare class ProxyApi extends runtime.BaseAPI {
+    /**
+     * Thorchain rpc rest api endpoints.
+     */
+    getRPCRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Thorchain rpc rest api endpoints.
+     */
+    getRPC(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Thorchain lcd rest api endpoints.
      */
@@ -31,11 +39,11 @@ export declare class ProxyApi extends runtime.BaseAPI {
      */
     midgard(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
-     * Thorchain rpc rest api endpoints.
+     * Thorchain rpc jsonrpc endpoints.
      */
-    rPCRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    postRPCRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * Thorchain rpc rest api endpoints.
+     * Thorchain rpc jsonrpc endpoints.
      */
-    rPC(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    postRPC(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 }

package/dist/cjs/generated/thorchain/apis/ProxyApi.js

@@ -43,6 +43,26 @@ const runtime = __importStar(require("../runtime"));
  *
  */
 class ProxyApi extends runtime.BaseAPI {
+    /**
+     * Thorchain rpc rest api endpoints.
+     */
+    async getRPCRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        const response = await this.request({
+            path: `/rpc`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Thorchain rpc rest api endpoints.
+     */
+    async getRPC(initOverrides) {
+        await this.getRPCRaw(initOverrides);
+    }
     /**
      * Thorchain lcd rest api endpoints.
      */
@@ -84,24 +104,24 @@ class ProxyApi extends runtime.BaseAPI {
         await this.midgardRaw(initOverrides);
     }
     /**
-     * Thorchain rpc rest api endpoints.
+     * Thorchain rpc jsonrpc endpoints.
      */
-    async rPCRaw(initOverrides) {
+    async postRPCRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
         const response = await this.request({
             path: `/rpc`,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Thorchain rpc rest api endpoints.
+     * Thorchain rpc jsonrpc endpoints.
      */
-    async rPC(initOverrides) {
-        await this.rPCRaw(initOverrides);
+    async postRPC(initOverrides) {
+        await this.postRPCRaw(initOverrides);
     }
 }
 exports.ProxyApi = ProxyApi;

package/dist/cjs/index.d.ts

@@ -4,6 +4,7 @@ export * as evm from './evm';
 export * as utxo from './utxo';
 export * as cosmossdk from './cosmossdk';
 export * as solana from './solana';
+export * as tron from './tron';
 export * as common from './parser';
 export * as ethereum from './evm/ethereum';
 export * as avalanche from './evm/avalanche';

package/dist/cjs/index.js

@@ -26,13 +26,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mayachain = exports.thorchainV1 = exports.thorchain = exports.cosmos = exports.litecoin = exports.dogecoin = exports.bitcoincash = exports.bitcoin = exports.base = exports.arbitrumNova = exports.arbitrum = exports.gnosis = exports.polygon = exports.bnbsmartchain = exports.optimism = exports.avalanche = exports.ethereum = exports.common = exports.solana = exports.cosmossdk = exports.utxo = exports.evm = exports.ws = void 0;
+exports.mayachain = exports.thorchainV1 = exports.thorchain = exports.cosmos = exports.litecoin = exports.dogecoin = exports.bitcoincash = exports.bitcoin = exports.base = exports.arbitrumNova = exports.arbitrum = exports.gnosis = exports.polygon = exports.bnbsmartchain = exports.optimism = exports.avalanche = exports.ethereum = exports.common = exports.tron = exports.solana = exports.cosmossdk = exports.utxo = exports.evm = exports.ws = void 0;
 __exportStar(require("./types"), exports);
 exports.ws = __importStar(require("./websocket"));
 exports.evm = __importStar(require("./evm"));
 exports.utxo = __importStar(require("./utxo"));
 exports.cosmossdk = __importStar(require("./cosmossdk"));
 exports.solana = __importStar(require("./solana"));
+exports.tron = __importStar(require("./tron"));
 exports.common = __importStar(require("./parser"));
 exports.ethereum = __importStar(require("./evm/ethereum"));
 exports.avalanche = __importStar(require("./evm/avalanche"));

package/dist/cjs/tron/api.d.ts

@@ -0,0 +1,66 @@
+import type { TronBlock, TronTx } from './types';
+export interface TronApiConfig {
+    rpcUrl: string;
+}
+export declare class TronApi {
+    private readonly rpcUrl;
+    private tronWeb;
+    private requestQueue;
+    private readonly minRequestInterval;
+    constructor(config: TronApiConfig);
+    getRpcUrl(): string;
+    private throttle;
+    private getTronWeb;
+    getAccount(params: {
+        pubkey: string;
+    }): Promise<{
+        balance: string;
+        unconfirmedBalance: string;
+        tokens?: {
+            contractAddress: string;
+            balance: string;
+        }[];
+    }>;
+    getTRC20Balance(params: {
+        address: string;
+        contractAddress: string;
+    }): Promise<string>;
+    getTxHistory(_params: {
+        pubkey: string;
+        pageSize?: number;
+        cursor?: string;
+    }): Promise<{
+        txs: TronTx[];
+        cursor?: string;
+    }>;
+    getTransaction(params: {
+        txid: string;
+    }): Promise<TronTx | null>;
+    getBlock(params: {
+        height: number;
+    }): Promise<TronBlock | null>;
+    sendTx(params: {
+        sendTxBody: {
+            hex: string;
+        };
+    }): Promise<string>;
+    private getChainPrices;
+    estimateFees(params: {
+        estimateFeesBody: {
+            serializedTx: string;
+        };
+    }): Promise<string>;
+    estimateTRC20TransferFee(params: {
+        contractAddress: string;
+        from: string;
+        to: string;
+        amount: string;
+    }): Promise<string>;
+    getPriorityFees(): Promise<{
+        baseFee: string;
+        fast: string;
+        average: string;
+        slow: string;
+        estimatedBandwidth: string;
+    }>;
+}

package/dist/cjs/tron/api.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronApi = void 0;
+const tronweb_1 = require("tronweb");
+class TronApi {
+    rpcUrl;
+    tronWeb = null;
+    requestQueue = Promise.resolve();
+    minRequestInterval = 1_500;
+    constructor(config) {
+        this.rpcUrl = config.rpcUrl;
+    }
+    getRpcUrl() {
+        return this.rpcUrl;
+    }
+    async throttle() {
+        // Queue the request and wait for all previous requests to complete
+        const currentRequest = this.requestQueue.then(async () => {
+            await new Promise(resolve => setTimeout(resolve, this.minRequestInterval));
+        });
+        this.requestQueue = currentRequest;
+        await currentRequest;
+    }
+    getTronWeb() {
+        if (!this.tronWeb) {
+            this.tronWeb = new tronweb_1.TronWeb({ fullHost: this.rpcUrl });
+        }
+        return this.tronWeb;
+    }
+    async getAccount(params) {
+        await this.throttle();
+        const response = await fetch(`${this.rpcUrl}/wallet/getaccount`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ address: params.pubkey, visible: true }),
+        });
+        const data = await response.json();
+        const tokens = [];
+        // Get TRC10 tokens from assetV2
+        if (data.assetV2) {
+            data.assetV2.forEach(token => {
+                tokens.push({
+                    contractAddress: token.key,
+                    balance: String(token.value),
+                });
+            });
+        }
+        // Get TRC20 tokens from TronGrid API
+        try {
+            await this.throttle();
+            const trc20Response = await fetch(`${this.rpcUrl}/v1/accounts/${params.pubkey}`);
+            const trc20Data = await trc20Response.json();
+            if (trc20Data.data?.[0]?.trc20 && Array.isArray(trc20Data.data[0].trc20)) {
+                // trc20 is an array of objects like [{contractAddress: balance}, ...]
+                trc20Data.data[0].trc20.forEach((tokenObj) => {
+                    for (const [contractAddress, balance] of Object.entries(tokenObj)) {
+                        tokens.push({
+                            contractAddress,
+                            balance: String(balance),
+                        });
+                    }
+                });
+            }
+        }
+        catch (err) {
+            // TRC20 fetch failed, continue with just TRC10 tokens
+            console.error('Failed to fetch TRC20 tokens:', err);
+        }
+        return {
+            balance: data.balance ? String(data.balance) : '0',
+            unconfirmedBalance: '0',
+            tokens,
+        };
+    }
+    async getTRC20Balance(params) {
+        try {
+            const tronWeb = await this.getTronWeb();
+            const contract = await tronWeb.contract().at(params.contractAddress);
+            const balance = await contract.balanceOf(params.address).call();
+            return balance.toString();
+        }
+        catch (_err) {
+            return '0';
+        }
+    }
+    getTxHistory(_params) {
+        throw new Error('Transaction history is not supported for TRON');
+    }
+    async getTransaction(params) {
+        await this.throttle();
+        const response = await fetch(`${this.rpcUrl}/wallet/gettransactionbyid`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ value: params.txid, visible: true }),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const tx = await response.json();
+        if (!tx || !tx.txID) {
+            return null;
+        }
+        return {
+            ...tx,
+            txid: tx.txID,
+            blockHash: '',
+            blockHeight: 0,
+            timestamp: 0,
+            confirmations: 0,
+            value: '0',
+            fee: '0',
+        };
+    }
+    async getBlock(params) {
+        await this.throttle();
+        const response = await fetch(`${this.rpcUrl}/wallet/getblockbynum`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ num: params.height }),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return await response.json();
+    }
+    async sendTx(params) {
+        const tronWeb = this.getTronWeb();
+        try {
+            const signedTxJson = JSON.parse(params.sendTxBody.hex);
+            const result = await tronWeb.trx.sendRawTransaction(signedTxJson);
+            if (!result.result) {
+                throw new Error(result.message || JSON.stringify(result) || 'Failed to broadcast transaction');
+            }
+            const txid = result.txid || result.transaction?.txID;
+            if (!txid) {
+                throw new Error('Transaction ID not found in broadcast result');
+            }
+            return txid;
+        }
+        catch (error) {
+            throw new Error(`Failed to broadcast TRON transaction: ${error}`);
+        }
+    }
+    async getChainPrices() {
+        try {
+            const tronWeb = await this.getTronWeb();
+            const params = await tronWeb.trx.getChainParameters();
+            const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
+            const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 420;
+            return { bandwidthPrice, energyPrice };
+        }
+        catch (_err) {
+            return { bandwidthPrice: 1000, energyPrice: 420 };
+        }
+    }
+    async estimateFees(params) {
+        try {
+            const { bandwidthPrice } = await this.getChainPrices();
+            const rawDataBytes = Buffer.from(params.estimateFeesBody.serializedTx, 'hex').length;
+            const signatureBytes = 65;
+            const totalBytes = rawDataBytes + signatureBytes;
+            const feeInSun = totalBytes * bandwidthPrice;
+            return String(feeInSun);
+        }
+        catch (err) {
+            throw new Error(`Failed to estimate fees: ${err}`);
+        }
+    }
+    async estimateTRC20TransferFee(params) {
+        try {
+            const tronWeb = await this.getTronWeb();
+            const { energyPrice } = await this.getChainPrices();
+            const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'transfer(address,uint256)', {}, [
+                { type: 'address', value: params.to },
+                { type: 'uint256', value: params.amount },
+            ], params.from);
+            const energyUsed = result.energy_used ?? 0;
+            const feeInSun = energyUsed * energyPrice;
+            return String(feeInSun);
+        }
+        catch (_err) {
+            return '31000000';
+        }
+    }
+    async getPriorityFees() {
+        try {
+            const { bandwidthPrice } = await this.getChainPrices();
+            const estimatedBytes = 268;
+            const baseFee = String(estimatedBytes * bandwidthPrice);
+            return {
+                baseFee,
+                fast: baseFee,
+                average: baseFee,
+                slow: baseFee,
+                estimatedBandwidth: String(estimatedBytes),
+            };
+        }
+        catch (_err) {
+            const defaultFee = '268000';
+            return {
+                baseFee: defaultFee,
+                fast: defaultFee,
+                average: defaultFee,
+                slow: defaultFee,
+                estimatedBandwidth: '268',
+            };
+        }
+    }
+}
+exports.TronApi = TronApi;

package/dist/cjs/tron/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './parser';
+export * from './types';

package/dist/cjs/tron/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/tron/parser/index.d.ts

@@ -0,0 +1,16 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { ParsedTx } from '../../types';
+import type { TronTx } from '../types';
+export interface TransactionParserArgs {
+    assetId: AssetId;
+    chainId: ChainId;
+}
+export declare class TransactionParser {
+    assetId: AssetId;
+    chainId: ChainId;
+    assetReference: string;
+    constructor(args: TransactionParserArgs);
+    parse(tx: TronTx, address: string): Promise<ParsedTx>;
+    private getStatus;
+    private getTransfers;
+}

package/dist/cjs/tron/parser/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionParser = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("../../types");
+class TransactionParser {
+    assetId;
+    chainId;
+    assetReference;
+    constructor(args) {
+        this.assetId = args.assetId;
+        this.chainId = args.chainId;
+        const { assetReference } = (0, caip_1.fromAssetId)(this.assetId);
+        this.assetReference = assetReference;
+    }
+    parse(tx, address) {
+        const parsedTx = {
+            address,
+            blockHash: tx.blockHash || '',
+            blockHeight: tx.blockHeight || 0,
+            blockTime: tx.timestamp ? Math.floor(tx.timestamp / 1000) : 0,
+            chainId: this.chainId,
+            confirmations: tx.confirmations || 0,
+            status: this.getStatus(tx),
+            transfers: this.getTransfers(tx, address),
+            txid: tx.txID,
+            trade: undefined,
+            fee: {
+                assetId: this.assetId,
+                value: tx.fee || '0',
+            },
+        };
+        return Promise.resolve(parsedTx);
+    }
+    getStatus(tx) {
+        if (tx.confirmations && tx.confirmations > 0) {
+            return types_1.TxStatus.Confirmed;
+        }
+        return types_1.TxStatus.Pending;
+    }
+    getTransfers(tx, address) {
+        const transfers = [];
+        if (!tx.raw_data || !tx.raw_data.contract) {
+            return transfers;
+        }
+        for (const contract of tx.raw_data.contract) {
+            if (contract.type === 'TransferContract') {
+                const { owner_address, to_address, amount } = contract.parameter.value;
+                const value = String(amount || 0);
+                if (owner_address === address) {
+                    transfers.push({
+                        assetId: this.assetId,
+                        from: owner_address || '',
+                        to: to_address || '',
+                        type: types_1.TransferType.Send,
+                        totalValue: value,
+                        components: [{ value }],
+                    });
+                }
+                else if (to_address === address) {
+                    transfers.push({
+                        assetId: this.assetId,
+                        from: owner_address || '',
+                        to: to_address || '',
+                        type: types_1.TransferType.Receive,
+                        totalValue: value,
+                        components: [{ value }],
+                    });
+                }
+            }
+        }
+        return transfers;
+    }
+}
+exports.TransactionParser = TransactionParser;

package/dist/cjs/tron/types.d.ts

@@ -0,0 +1,66 @@
+export interface TronTx {
+    txid: string;
+    blockHash: string;
+    blockHeight: number;
+    timestamp: number;
+    confirmations: number;
+    value: string;
+    fee: string;
+    raw_data: {
+        contract: {
+            parameter: {
+                value: {
+                    amount?: number;
+                    owner_address?: string;
+                    to_address?: string;
+                };
+                type_url: string;
+            };
+            type: string;
+        }[];
+        ref_block_bytes: string;
+        ref_block_hash: string;
+        expiration: number;
+        timestamp: number;
+    };
+    raw_data_hex: string;
+    txID: string;
+    signature?: string[];
+}
+type TRC20Token = {
+    key: string;
+    value: number;
+};
+export interface TronAccount {
+    address: string;
+    balance: number;
+    create_time?: number;
+    latest_opration_time?: number;
+    account_resource?: {
+        energy_usage?: number;
+        frozen_balance_for_energy?: {
+            frozen_balance?: number;
+        };
+        net_usage?: number;
+        frozen_balance_for_net?: {
+            frozen_balance?: number;
+        };
+    };
+    assetV2?: TRC20Token[];
+}
+export interface TronBlock {
+    blockID: string;
+    block_header: {
+        raw_data: {
+            number: number;
+            txTrieRoot: string;
+            witness_address: string;
+            parentHash: string;
+            version: number;
+            timestamp: number;
+        };
+        witness_signature: string;
+    };
+    transactions?: TronTx[];
+}
+export {};

package/dist/cjs/tron/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });