@shapeshiftoss/unchained-client 10.14.7 → 10.14.10

package/dist/esm/solana/parser/index.js

@@ -0,0 +1,120 @@
+import { ASSET_NAMESPACE, toAssetId } from '@shapeshiftoss/caip';
+import { BigAmount } from '@shapeshiftoss/utils';
+import { TransferType, TxStatus } from '../../types.js';
+import { aggregateTransfer } from '../../utils.js';
+import { TokenStandard } from './types.js';
+export * from './types.js';
+export class TransactionParser {
+    chainId;
+    assetId;
+    api;
+    parsers = [];
+    constructor(args) {
+        this.chainId = args.chainId;
+        this.assetId = args.assetId;
+        this.api = args.api;
+    }
+    /**
+     * Register custom transaction sub parser to parse custom op return data
+     *
+     * _parsers should be registered from most generic first to most specific last_
+     */
+    registerParser(parser) {
+        this.parsers.unshift(parser);
+    }
+    registerParsers(parsers) {
+        parsers.forEach(parser => this.registerParser(parser));
+    }
+    async parse(tx, address) {
+        const parserResult = await (async () => {
+            for (const parser of this.parsers) {
+                const result = await parser.parse(tx, address);
+                if (result)
+                    return result;
+            }
+        })();
+        const parsedTx = {
+            address,
+            blockHeight: tx.blockHeight,
+            blockTime: tx.timestamp,
+            chainId: this.chainId,
+            // all transactions from unchained are finalized with at least 1 confirmation (unused throughout web)
+            confirmations: 1,
+            status: this.getStatus(tx),
+            trade: parserResult?.trade,
+            transfers: parserResult?.transfers ?? [],
+            txid: tx.txid,
+        };
+        // network fee
+        if (tx.fee && address === tx.feePayer) {
+            parsedTx.fee = { assetId: this.assetId, value: BigInt(tx.fee).toString() };
+        }
+        tx.nativeTransfers?.forEach(nativeTransfer => {
+            const { amount, fromUserAccount, toUserAccount } = nativeTransfer;
+            const makeTransferArgs = (type) => ({
+                assetId: this.assetId,
+                from: fromUserAccount ?? '',
+                to: toUserAccount ?? '',
+                transfers: parsedTx.transfers,
+                type,
+                value: BigInt(amount).toString(),
+            });
+            // send amount
+            if (address === nativeTransfer.fromUserAccount) {
+                parsedTx.transfers = aggregateTransfer(makeTransferArgs(TransferType.Send));
+            }
+            // receive amount
+            if (address === nativeTransfer.toUserAccount) {
+                parsedTx.transfers = aggregateTransfer(makeTransferArgs(TransferType.Receive));
+            }
+        });
+        for (const tokenTransfer of tx.tokenTransfers ?? []) {
+            const { tokenAmount, fromUserAccount, toUserAccount, mint, tokenStandard } = tokenTransfer;
+            // only parse fungible tokens
+            if (tokenStandard !== TokenStandard.Fungible)
+                continue;
+            try {
+                const token = await this.api.getToken({ id: mint });
+                const assetId = toAssetId({
+                    chainId: this.chainId,
+                    assetNamespace: ASSET_NAMESPACE.splToken,
+                    assetReference: mint,
+                });
+                const makeTransferArgs = (type) => ({
+                    assetId,
+                    from: fromUserAccount ?? '',
+                    to: toUserAccount ?? '',
+                    token: {
+                        decimals: token.decimals,
+                        contract: token.id,
+                        name: token.name,
+                        symbol: token.symbol,
+                    },
+                    transfers: parsedTx.transfers,
+                    type,
+                    value: BigAmount.fromPrecision({
+                        value: tokenAmount,
+                        precision: token.decimals,
+                    }).toBaseUnit(),
+                });
+                // token send amount
+                if (address === fromUserAccount) {
+                    parsedTx.transfers = aggregateTransfer(makeTransferArgs(TransferType.Send));
+                }
+                // token receive amount
+                if (address === toUserAccount) {
+                    parsedTx.transfers = aggregateTransfer(makeTransferArgs(TransferType.Receive));
+                }
+            }
+            catch (err) {
+                console.warn(`failed to parse token transfer: ${tokenTransfer}: ${err}`);
+            }
+        }
+        return parsedTx;
+    }
+    getStatus(tx) {
+        if (tx.transactionError)
+            return TxStatus.Failed;
+        return TxStatus.Confirmed;
+    }
+}

package/dist/esm/solana/parser/types.d.ts

@@ -0,0 +1,10 @@
+import type * as solana from '../../generated/solana/index.js';
+import type { StandardTx } from '../../types.js';
+export * from '../../generated/solana/index.js';
+export type Tx = solana.Tx;
+export interface ParsedTx extends StandardTx {
+}
+export type TxSpecific = Partial<Pick<ParsedTx, 'trade' | 'transfers'>>;
+export interface SubParser<T extends Tx, U = TxSpecific> {
+    parse(tx: T, address: string): Promise<U | undefined>;
+}

package/dist/esm/solana/parser/types.js

@@ -0,0 +1 @@
+export * from '../../generated/solana/index.js';

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

@@ -0,0 +1,66 @@
+import type { TronBlock, TronTx } from './types.js';
+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/esm/tron/api.js

@@ -0,0 +1,229 @@
+import { TronWeb } from 'tronweb';
+export 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({ 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 [txResponse, infoResponse] = await Promise.all([
+            fetch(`${this.rpcUrl}/wallet/gettransactionbyid`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ value: params.txid, visible: true }),
+            }),
+            fetch(`${this.rpcUrl}/wallet/gettransactioninfobyid`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ value: params.txid, visible: true }),
+            }),
+        ]);
+        if (!txResponse.ok) {
+            return null;
+        }
+        const tx = await txResponse.json();
+        if (!tx || !tx.txID) {
+            return null;
+        }
+        let blockNumber = 0;
+        let blockTimeStamp = 0;
+        let fee = '0';
+        let log = [];
+        let internal_transactions = [];
+        if (infoResponse.ok) {
+            const info = await infoResponse.json();
+            blockNumber = info.blockNumber || 0;
+            blockTimeStamp = info.blockTimeStamp || 0;
+            fee = info.fee ? String(info.fee) : '0';
+            log = info.log || [];
+            internal_transactions = info.internal_transactions || [];
+        }
+        return {
+            ...tx,
+            txid: tx.txID,
+            blockHash: '',
+            blockHeight: blockNumber,
+            timestamp: blockTimeStamp,
+            confirmations: blockNumber > 0 ? 1 : 0,
+            value: '0',
+            fee,
+            log,
+            internal_transactions,
+        };
+    }
+    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) {
+            // Fallback: Worst case 130k energy at current 100 sun/energy
+            return '13000000'; // 13 TRX (more realistic than 31 TRX)
+        }
+    }
+    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',
+            };
+        }
+    }
+}

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

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

package/dist/esm/tron/index.js

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

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

@@ -0,0 +1,16 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { ParsedTx } from '../../types.js';
+import type { TronTx } from '../types.js';
+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/esm/tron/parser/index.js

@@ -0,0 +1,71 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { TransferType, TxStatus as Status } from '../../types.js';
+export class TransactionParser {
+    assetId;
+    chainId;
+    assetReference;
+    constructor(args) {
+        this.assetId = args.assetId;
+        this.chainId = args.chainId;
+        const { assetReference } = 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 Status.Confirmed;
+        }
+        return Status.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: TransferType.Send,
+                        totalValue: value,
+                        components: [{ value }],
+                    });
+                }
+                else if (to_address === address) {
+                    transfers.push({
+                        assetId: this.assetId,
+                        from: owner_address || '',
+                        to: to_address || '',
+                        type: TransferType.Receive,
+                        totalValue: value,
+                        components: [{ value }],
+                    });
+                }
+            }
+        }
+        return transfers;
+    }
+}

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

@@ -0,0 +1,88 @@
+export interface TronTxLog {
+    address: string;
+    topics: string[];
+    data: string;
+}
+export interface TronInternalTransaction {
+    hash: string;
+    caller_address: string;
+    transferTo_address: string;
+    callValueInfo: {
+        callValue?: number;
+        tokenId?: string;
+    }[];
+    note: string;
+    rejected?: boolean;
+}
+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[];
+    ret?: {
+        contractRet?: 'SUCCESS' | 'REVERT' | string;
+        fee?: number;
+    }[];
+    log?: TronTxLog[];
+    internal_transactions?: TronInternalTransaction[];
+}
+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/esm/tron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types.d.ts

@@ -0,0 +1,67 @@
+export declare enum Dex {
+    Thor = "THORChain",
+    Zrx = "0x",
+    CowSwap = "CoW Swap",
+    Maya = "MAYAChain"
+}
+export interface Fee {
+    assetId: string;
+    value: string;
+}
+export declare enum TxStatus {
+    Confirmed = "Confirmed",
+    Pending = "Pending",
+    Failed = "Failed",
+    Unknown = "Unknown"
+}
+export interface Token {
+    contract: string;
+    decimals: number;
+    name: string;
+    symbol: string;
+}
+export interface Trade {
+    dexName: Dex;
+    memo?: string;
+    type: TradeType;
+}
+export declare enum TradeType {
+    Trade = "Trade",
+    Swap = "Swap",
+    Refund = "Refund"
+}
+export interface Transfer {
+    from: string;
+    to: string;
+    assetId: string;
+    type: TransferType;
+    totalValue: string;
+    components: {
+        value: string;
+    }[];
+    token?: Token;
+    id?: string;
+}
+export declare enum TransferType {
+    Send = "Send",
+    Receive = "Receive",
+    Contract = "Contract"
+}
+export interface BaseTxMetadata {
+    method?: string;
+    parser: string;
+}
+export interface StandardTx {
+    address: string;
+    blockHash?: string;
+    blockHeight: number;
+    blockTime: number;
+    chainId: string;
+    confirmations: number;
+    fee?: Fee;
+    status: TxStatus;
+    trade?: Trade;
+    transfers: Transfer[];
+    txid: string;
+}
+export type ParsedTx = StandardTx;