viem/_cjs/tempo/internal/utils.js

TypeScript Interface for Ethereum

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveToken = resolveToken;
exports.findDeclaredToken = findDeclaredToken;
exports.resolveTokenWithDecimals = resolveTokenWithDecimals;
exports.pickWriteParameters = pickWriteParameters;
exports.resolveCallParameters = resolveCallParameters;
exports.defineCall = defineCall;
exports.normalizeValue = normalizeValue;
const tempo_1 = require("ox/tempo");
const readContract_js_1 = require("../../actions/public/readContract.js");
const isAddressEqual_js_1 = require("../../utils/address/isAddressEqual.js");
const index_js_1 = require("../../utils/index.js");
const Abis = require("../Abis.js");
function resolveToken(client, parameters) {
    const { decimals, token } = parameters;
    if (client && typeof token === 'string') {
        const declared = findDeclaredTokenBySymbol(client, token);
        if (declared)
            return {
                address: declared.address,
                decimals: decimals ?? declared.decimals,
            };
    }
    const address = tempo_1.TokenId.toAddress(token);
    return {
        address,
        decimals: decimals ?? (client ? inferDecimals(client, address) : undefined),
    };
}
function findDeclaredToken(client, token) {
    const tokens = client.tokens;
    const chainId = client.chain?.id;
    if (!tokens || chainId === undefined)
        return undefined;
    if (typeof token === 'string') {
        const declared = findDeclaredTokenBySymbol(client, token);
        if (declared)
            return declared;
    }
    const address = tempo_1.TokenId.toAddress(token);
    for (const token_ of tokens) {
        const resolved = resolveTokenForChain(token_, chainId);
        if (resolved && (0, isAddressEqual_js_1.isAddressEqual)(resolved.address, address))
            return resolved;
    }
    return undefined;
}
function findDeclaredTokenBySymbol(client, symbol) {
    const tokens = client.tokens;
    const chainId = client.chain?.id;
    if (!tokens || chainId === undefined)
        return undefined;
    const lowerSymbol = symbol.toLowerCase();
    for (const token of tokens) {
        if (token.symbol?.toLowerCase() === lowerSymbol)
            return resolveTokenForChain(token, chainId);
    }
    return undefined;
}
function resolveTokenForChain(token, chainId) {
    const address = token.addresses[chainId];
    if (!address)
        return undefined;
    return {
        address,
        currency: token.currency,
        decimals: token.decimals,
        name: token.name,
        popular: token.popular,
        symbol: token.symbol,
    };
}
function inferDecimals(client, address) {
    const tokens = client.tokens;
    const chainId = client.chain?.id;
    if (tokens && chainId !== undefined)
        for (const token of tokens) {
            const resolved = resolveTokenForChain(token, chainId);
            if (resolved && (0, isAddressEqual_js_1.isAddressEqual)(resolved.address, address))
                return resolved.decimals;
        }
    return undefined;
}
async function resolveTokenWithDecimals(client, parameters) {
    const { address, decimals } = resolveToken(client, parameters);
    if (decimals !== undefined)
        return { address, decimals };
    return {
        address,
        decimals: await (0, readContract_js_1.readContract)(client, {
            abi: Abis.tip20,
            address,
            functionName: 'decimals',
        }),
    };
}
function pickWriteParameters(parameters) {
    const { account, chain, feePayer, feeToken, gas, keyAuthorization, maxFeePerGas, maxPriorityFeePerGas, nonce, nonceKey, validAfter, validBefore, } = parameters;
    return {
        account,
        chain,
        feePayer,
        feeToken,
        gas,
        keyAuthorization,
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        nonceKey,
        validAfter,
        validBefore,
    };
}
function resolveCallParameters(parameters) {
    if (parameters.length === 2)
        return parameters;
    return [undefined, parameters[0]];
}
function defineCall(call) {
    return {
        ...call,
        data: (0, index_js_1.encodeFunctionData)(call),
        to: call.address,
    };
}
function normalizeValue(value) {
    if (Array.isArray(value))
        return value.map(normalizeValue);
    if (typeof value === 'function')
        return undefined;
    if (typeof value !== 'object' || value === null)
        return value;
    if (Object.getPrototypeOf(value) !== Object.prototype)
        try {
            return structuredClone(value);
        }
        catch {
            return undefined;
        }
    const normalized = {};
    for (const [k, v] of Object.entries(value))
        normalized[k] = normalizeValue(v);
    return normalized;
}
//# sourceMappingURL=utils.js.map