@shapeshiftoss/unchained-client 10.14.7 → 10.14.8

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 });

package/dist/cjs/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;

package/dist/cjs/types.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferType = exports.TradeType = exports.TxStatus = exports.Dex = void 0;
+// these are user facing values, and should be rendered as such
+var Dex;
+(function (Dex) {
+    Dex["Thor"] = "THORChain";
+    Dex["Zrx"] = "0x";
+    Dex["CowSwap"] = "CoW Swap";
+    Dex["Maya"] = "MAYAChain";
+})(Dex || (exports.Dex = Dex = {}));
+// these are user facing values, and should be rendered as such
+var TxStatus;
+(function (TxStatus) {
+    TxStatus["Confirmed"] = "Confirmed";
+    TxStatus["Pending"] = "Pending";
+    TxStatus["Failed"] = "Failed";
+    TxStatus["Unknown"] = "Unknown";
+})(TxStatus || (exports.TxStatus = TxStatus = {}));
+// these are user facing values, and should be rendered as such
+var TradeType;
+(function (TradeType) {
+    TradeType["Trade"] = "Trade";
+    TradeType["Swap"] = "Swap";
+    TradeType["Refund"] = "Refund";
+})(TradeType || (exports.TradeType = TradeType = {}));
+// these are user facing values, and should be rendered as such
+var TransferType;
+(function (TransferType) {
+    TransferType["Send"] = "Send";
+    TransferType["Receive"] = "Receive";
+    TransferType["Contract"] = "Contract";
+})(TransferType || (exports.TransferType = TransferType = {}));

package/dist/cjs/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Token, Transfer, TransferType } from './types';
+export declare function findAsyncSequential<T, U>(array: T[], predicate: (element: T) => Promise<U | undefined>): Promise<U | undefined>;
+export interface AggregateTransferArgs {
+    assetId: string;
+    from: string;
+    id?: string;
+    to: string;
+    token?: Token;
+    transfers: Transfer[];
+    type: TransferType;
+    value: string;
+    allowZeroValue?: boolean;
+}
+export declare function aggregateTransfer(args: AggregateTransferArgs): Transfer[];

package/dist/cjs/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateTransfer = exports.findAsyncSequential = void 0;
+const bignumber_js_1 = require("bignumber.js");
+async function findAsyncSequential(array, predicate) {
+    for (const element of array) {
+        const result = await predicate(element);
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}
+exports.findAsyncSequential = findAsyncSequential;
+// keep track of all individual tx components and add up the total value transferred
+function aggregateTransfer(args) {
+    const { allowZeroValue, assetId, from, id, to, token, transfers, type, value } = args;
+    if (!allowZeroValue && !new bignumber_js_1.BigNumber(value).gt(0))
+        return transfers;
+    const index = transfers?.findIndex(t => t.type === type && t.assetId === assetId && t.from === from && t.to === to && t.id === id);
+    const transfer = transfers?.[index];
+    if (transfer) {
+        transfer.totalValue = new bignumber_js_1.BigNumber(transfer.totalValue).plus(value).toString(10);
+        transfer.components.push({ value });
+        transfers[index] = transfer;
+    }
+    else {
+        transfers.push({
+            type,
+            assetId,
+            from,
+            to,
+            totalValue: value,
+            components: [{ value }],
+            token,
+            id,
+        });
+    }
+    return transfers;
+}
+exports.aggregateTransfer = aggregateTransfer;

package/dist/cjs/utxo/bitcoin/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../../generated/bitcoin';
+export * from './parser';

package/dist/cjs/utxo/bitcoin/index.js

@@ -0,0 +1,18 @@
+"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("../../generated/bitcoin"), exports);
+__exportStar(require("./parser"), exports);

package/dist/cjs/utxo/bitcoin/parser/__tests__/bitcoin.test.d.ts

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