@ledgerhq/hw-app-eth/lib/services/ledger/erc20.js

Ledger Hardware Wallet Ethereum Application API

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.byContractAddressAndChainId = exports.findERC20SignaturesInfo = void 0;
const axios_1 = __importDefault(require("axios"));
const logs_1 = require("@ledgerhq/logs");
const loadConfig_1 = require("./loadConfig");
const asContractAddress = (addr) => {
    const a = addr.toLowerCase();
    return a.startsWith("0x") ? a : "0x" + a;
};
const findERC20SignaturesInfo = async (userLoadConfig, chainId) => {
    const { cryptoassetsBaseURL } = (0, loadConfig_1.getLoadConfig)(userLoadConfig);
    if (!cryptoassetsBaseURL)
        return null;
    const url = `${cryptoassetsBaseURL}/evm/${chainId}/erc20-signatures.json`;
    const blob = await axios_1.default
        .get(url)
        .then(({ data }) => {
        if (!data || typeof data !== "string") {
            throw new Error(`ERC20 signatures for chainId ${chainId} file is malformed ${url}`);
        }
        return data;
    })
        .catch(e => {
        (0, logs_1.log)("error", "could not fetch from " + url + ": " + String(e));
        return null;
    });
    return blob;
};
exports.findERC20SignaturesInfo = findERC20SignaturesInfo;
/**
 * Retrieve the token information by a given contract address if any
 */
const byContractAddressAndChainId = (contract, chainId, erc20SignaturesBlob, userLoadConfig) => {
    // If we are able to fetch data from s3 bucket that contains dynamic CAL
    if (erc20SignaturesBlob) {
        try {
            return parse(erc20SignaturesBlob).byContractAndChainId(asContractAddress(contract), chainId);
        }
        catch (e) {
            // Fall through to static fallback if dynamic CAL parsing fails
        }
    }
    // Static fallback from injected signatures (for external library users)
    const loadConfig = userLoadConfig ? (0, loadConfig_1.getLoadConfig)(userLoadConfig) : null;
    if (loadConfig?.staticERC20Signatures?.[chainId]) {
        try {
            return parse(loadConfig.staticERC20Signatures[chainId]).byContractAndChainId(asContractAddress(contract), chainId);
        }
        catch (e) {
            (0, logs_1.log)("error", `Failed to parse static ERC20 signatures for chainId ${chainId}: ${String(e)}`);
        }
    }
    return null;
};
exports.byContractAddressAndChainId = byContractAddressAndChainId;
const parse = (erc20SignaturesBlob) => {
    const buf = Buffer.from(erc20SignaturesBlob, "base64");
    const map = {};
    const entries = [];
    let i = 0;
    while (i < buf.length) {
        const length = buf.readUInt32BE(i);
        i += 4;
        const item = buf.slice(i, i + length);
        let j = 0;
        const tickerLength = item.readUInt8(j);
        j += 1;
        const ticker = item.slice(j, j + tickerLength).toString("ascii");
        j += tickerLength;
        const contractAddress = asContractAddress(item.slice(j, j + 20).toString("hex"));
        j += 20;
        const decimals = item.readUInt32BE(j);
        j += 4;
        const chainId = item.readUInt32BE(j);
        j += 4;
        const signature = item.slice(j);
        const entry = {
            ticker,
            contractAddress,
            decimals,
            chainId,
            signature,
            data: item,
        };
        entries.push(entry);
        map[String(chainId) + ":" + contractAddress] = entry;
        i += length;
    }
    return {
        list: () => entries,
        byContractAndChainId: (contractAddress, chainId) => map[String(chainId) + ":" + contractAddress],
    };
};
//# sourceMappingURL=erc20.js.map