@ledgerhq/coin-stellar/lib-es/bridge/tokens.js

Ledger Stellar Coin integration

import BigNumber from "bignumber.js";
import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
export const getAssetIdFromTokenId = (tokenId) => tokenId.split("/")[2];
const getAssetIdFromAsset = (asset) => `${asset.asset_code}:${asset.asset_issuer}`;
function buildStellarTokenAccount({ parentAccountId, stellarAsset, token, operations, }) {
    const assetId = getAssetIdFromTokenId(token.id);
    const id = `${parentAccountId}+${assetId}`;
    const balance = parseCurrencyUnit(token.units[0], stellarAsset.balance || "0");
    const reservedBalance = new BigNumber(stellarAsset.balance).minus(stellarAsset.selling_liabilities || 0);
    const spendableBalance = parseCurrencyUnit(token.units[0], reservedBalance.toString());
    return {
        type: "TokenAccount",
        id,
        parentId: parentAccountId,
        token,
        operationsCount: operations.length,
        operations: operations.map(op => ({
            ...op,
            id: encodeOperationId(id, op.hash, op.extra.ledgerOpType),
            accountId: id,
            type: op.extra.ledgerOpType,
            value: op.extra.assetAmount ? new BigNumber(op.extra.assetAmount) : op.value,
        })),
        pendingOperations: [],
        balance,
        spendableBalance,
        swapHistory: [],
        creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
    };
}
export function buildSubAccounts({ currency, accountId, assets, syncConfig, operations, }) {
    const { blacklistedTokenIds = [] } = syncConfig;
    const allTokens = listTokensForCryptoCurrency(currency);
    if (allTokens.length === 0 || assets.length === 0) {
        return undefined;
    }
    const tokenAccounts = [];
    assets.map(asset => {
        const token = findTokenById(`stellar/asset/${getAssetIdFromAsset(asset)}`);
        if (token && !blacklistedTokenIds.includes(token.id)) {
            tokenAccounts.push(buildStellarTokenAccount({
                parentAccountId: accountId,
                stellarAsset: asset,
                token,
                operations: operations.filter(op => op.extra.assetCode === asset.asset_code &&
                    op.extra.assetIssuer === asset.asset_issuer),
            }));
        }
    });
    return tokenAccounts;
}
//# sourceMappingURL=tokens.js.map