@tronlink/core
Version:
The library serves as a core module within TronLink Extension, which provides low-level wallet functionality for both Tron and Ethereum networks, primary features includes account generation and transaction signing
239 lines • 10.4 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.LedgerTrxSigner = void 0;
// @ts-ignore
const tronweb_1 = require("tronweb");
const error_1 = require("../../base_wallet/error");
const LedgerSigner_1 = require("../../base_wallet/ledger/LedgerSigner");
const utils_1 = require("../../utils");
const LedgerTrxWebHid_1 = require("./LedgerTrxWebHid");
const exchanges_1 = __importDefault(require("./config/exchanges"));
const tokens_1 = __importDefault(require("./config/tokens"));
class LedgerTrxSigner extends LedgerSigner_1.LedgerSigner {
async ledgerSign(params) {
let isSignMessageV2;
let transaction;
let path;
let tronWebInstance;
let options;
({ data: transaction, path, options } = params);
({ isSignMessageV2, tronWebInstance } = options || { isSignMessageV2: false });
let contractType;
const ledgerWebHid = new LedgerTrxWebHid_1.LedgerTrxWebHid();
try {
if (typeof transaction === 'string') {
const tx = isSignMessageV2 ? Buffer.from(transaction).toString('hex') : transaction;
return await ledgerWebHid.signPersonalMessage(tx, path);
}
contractType = (0, utils_1.getTransactionContractType)(transaction);
const tokenInfo = [];
let extra = {};
switch (contractType) {
case 'TransferContract': {
//Transfer
if (transaction.raw_data.data) {
extra.note = transaction.raw_data.data;
}
break;
}
case 'TransferAssetContract': {
const ID = tronweb_1.TronWeb.toUtf8(transaction.raw_data.contract[0].parameter.value.asset_name);
// get token info
extra = await getTokenExtraInfo(transaction.raw_data.contract[0].parameter.value.asset_name, tronWebInstance);
if (transaction.raw_data.data) {
extra.note = transaction.raw_data.data;
}
const tokenObj = await getLedgerTokenInfo(ID);
if (tokenObj.message) {
tokenInfo.push(tokenObj.message);
}
break;
}
case 'WitnessCreateContract':
case 'ProposalCreateContract':
case 'ProposalApproveContract':
case 'ProposalDeleteContract':
case 'TriggerSmartContract':
case 'AccountPermissionUpdateContract': {
extra = transaction.extra || {};
break;
}
case 'ExchangeCreateContract': {
const token1 = await getTokenExtraInfo(transaction.raw_data.contract[0].parameter.value.first_token_id, tronWebInstance);
const token2 = await getTokenExtraInfo(transaction.raw_data.contract[0].parameter.value.second_token_id, tronWebInstance);
if (token1 !== undefined && token2 !== undefined) {
extra = {
token1: token1.token_name,
decimals1: token1.decimals,
token2: token2.token_name,
decimals2: token2.decimals,
};
if (token1.id !== 0) {
tokenInfo.push(getLedgerTokenInfo(token1.id).message);
}
if (token2.id !== 0) {
tokenInfo.push(getLedgerTokenInfo(token2.id).message);
}
}
break;
}
case 'ExchangeInjectContract': {
//ExchangeInjectContract
const exchangeDepositID = transaction.raw_data.contract[0].parameter.value.exchange_id;
const exchangeDeposit = getLedgerExchangeInfo(exchangeDepositID);
const exchangeDepositToken = getLedgerTokenInfo(tronweb_1.TronWeb.toUtf8(transaction.raw_data.contract[0].parameter.value.token_id));
// get exchange info
extra = {
pair: exchangeDeposit.pair,
// @ts-ignore
token: exchangeDepositToken.token_name,
// @ts-ignore
decimals: exchangeDepositToken.decimals,
};
if (exchangeDepositToken.id !== 0) {
tokenInfo.push(exchangeDepositToken.message);
}
break;
}
case 'ExchangeWithdrawContract': {
//ExchangeWithdrawContract
const exchangeWithdrawID = transaction.raw_data.contract[0].parameter.value.exchange_id;
const exchangeWithdraw = getLedgerExchangeInfo(exchangeWithdrawID);
const exchangeWithdrawToken = getLedgerTokenInfo(tronweb_1.TronWeb.toUtf8(transaction.raw_data.contract[0].parameter.value.token_id));
// get exchange info
extra = {
pair: exchangeWithdraw.pair,
// @ts-ignore
token: exchangeWithdrawToken.token_name,
// @ts-ignore
decimals: exchangeWithdrawToken.decimals,
};
if (exchangeWithdrawToken.id !== 0) {
tokenInfo.push(exchangeWithdrawToken.message);
}
break;
}
case 'ExchangeTransactionContract': {
//ExchangeTransactionContract
const exchangeID = transaction.raw_data.contract[0].parameter.value.exchange_id;
const exchange = getLedgerExchangeInfo(exchangeID);
// get exchange info
extra = {
pair: exchange.pair,
decimals1: exchange.decimals1,
decimals2: exchange.decimals2,
action: transaction.raw_data.contract[0].parameter.value.token_id === exchange.firstToken
? 'Sell'
: 'Buy',
};
tokenInfo.push(exchange.message);
break;
}
}
extra.hash = transaction.txID;
const signedResponse = await ledgerWebHid.signTransaction({
hex: transaction.raw_data_hex,
info: tokenInfo,
}, path);
if (Array.isArray(transaction.signature)) {
if (!transaction.signature.includes(signedResponse))
transaction.signature.push(signedResponse);
}
else {
transaction.signature = [signedResponse];
}
return transaction;
}
catch (error) {
const stakeV2Contracts = [
'FreezeBalanceV2Contract',
'UnfreezeBalanceV2Contract',
'WithdrawExpireUnfreezeContract',
'DelegateResourceContract',
'UnDelegateResourceContract',
'CancelAllUnfreezeV2Contract',
];
if (/Too many bytes to encode/.test(error.message)) {
return await signHash(ledgerWebHid, transaction, path);
}
else if (error.toString().includes('0x6a80') && stakeV2Contracts.includes(contractType)) {
return await signHash(ledgerWebHid, transaction, path);
}
else {
throw new error_1.SignError(error.message);
}
}
}
async ledgerSignTypedData(params) {
try {
const { data, path } = params;
const ledgerWebHid = new LedgerTrxWebHid_1.LedgerTrxWebHid();
const TypedDataEncoder = tronweb_1.utils._TypedDataEncoder;
const messageDigest = TypedDataEncoder.hash(data.domain, data.types, data.message).replace('0x', '');
return await ledgerWebHid.signTransactionHash(path, messageDigest);
}
catch (e) {
throw new error_1.SignError(e.message);
}
}
}
exports.LedgerTrxSigner = LedgerTrxSigner;
async function signHash(ledgerWebHid, transaction, path) {
try {
const signedResponse = await ledgerWebHid.signTransactionHash(path, transaction.txID);
if (Array.isArray(transaction.signature)) {
if (!transaction.signature.includes(signedResponse))
transaction.signature.push(signedResponse);
}
else {
transaction.signature = [signedResponse];
}
return transaction;
}
catch (e) {
throw e.message;
}
}
const getTokenExtraInfo = async (ID, tronWebInstance) => {
let tokenID = ID;
if (typeof tokenID != 'number') {
tokenID = tronweb_1.TronWeb.toUtf8(tokenID);
if (tokenID === '')
return { id: 0, decimals: 6, token_name: 'TRX' };
else
tokenID = parseInt(tokenID);
}
const { id, precision, name } = await tronWebInstance.trx.getTokenByID(tokenID);
return { id, decimals: precision, token_name: name };
};
const getLedgerTokenInfo = (ID) => {
let tokenID = ID;
if (typeof tokenID != 'number') {
if (tokenID === '')
tokenID = 0;
else
tokenID = parseInt(tokenID);
}
return (tokens_1.default.find((o) => o.id === tokenID) ?? {
id: 0,
message: '',
});
};
const getLedgerExchangeInfo = (ID) => {
let exchangeID = ID;
if (typeof exchangeID !== 'number') {
exchangeID = parseInt(exchangeID);
}
return (exchanges_1.default.find((o) => o.id === exchangeID) ?? {
id: 0,
message: '',
firstToken: '',
pair: '',
decimals1: 0,
decimals2: 0,
});
};
//# sourceMappingURL=LedgerTrxSigner.js.map