@broxus/js-core/dist/esm/models/vault-token/VaultTokenUtils.js

MobX-based JavaScript Core library

import { debug, formattedTokenAmount, groupCollapsed, groupEnd, sliceString } from '@broxus/js-utils';
import { inheritTextStyle, successLabelStyle, successTextStyle } from '../../console';
import { DEFAULT_NATIVE_CURRENCY_DECIMALS } from '../../constants';
import { vaultTokenRootContract } from '../../models/vault-token/contracts';
import { getFullContractState, resolveTvmAddress, toInt } from '../../utils';
import { getScanLink } from '../../utils/get-scan-link';
export class VaultTokenUtils {
    static async deployWallet(provider, tokenAddress, params, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.deployWallet({
            answerId: 0,
            deployWalletValue: params.deployWalletValue ?? toInt(1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            walletOwner: resolveTvmAddress(params.walletOwner),
        })
            .sendDelayed({
            amount: toInt(1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.walletOwner),
            ...args,
        });
    }
    static async burn(provider, tokenAddress, params, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.burnTokens({
            amount: params.amount,
            callbackTo: resolveTvmAddress(params.callbackTo),
            payload: params.payload,
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
            walletOwner: resolveTvmAddress(params.walletOwner),
        })
            .sendDelayed({
            amount: toInt(0.5, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    static async mint(provider, tokenAddress, params, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.mint({
            amount: params.amount,
            deployWalletValue: params.deployWalletValue ?? toInt(1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            notify: params.notify ?? false,
            payload: params.payload ?? '',
            recipient: resolveTvmAddress(params.recipient),
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(0.6, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    static async transferOwnership(provider, tokenAddress, params, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.transferOwnership({
            callbacks: params.callbacks ?? [],
            newOwner: resolveTvmAddress(params.newOwner),
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(5, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    static async disableBurnByRoot(provider, tokenAddress, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.disableBurnByRoot({ answerId: 0 })
            .sendDelayed({
            amount: toInt(0.1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            ...args,
        });
    }
    static async disableMint(provider, tokenAddress, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.disableMint({ answerId: 0 })
            .sendDelayed({
            amount: toInt(0.1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            ...args,
        });
    }
    static async setBurnPaused(provider, tokenAddress, params, args) {
        return vaultTokenRootContract(provider, tokenAddress)
            .methods.setBurnPaused({ answerId: 0, paused: params.paused })
            .sendDelayed({
            amount: toInt(0.1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            ...args,
        });
    }
    static async getDetails(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        if (!state?.isDeployed) {
            return undefined;
        }
        return Promise.all([
            VaultTokenUtils.getDecimals(connection, tokenAddress, state),
            VaultTokenUtils.getName(connection, tokenAddress, state),
            VaultTokenUtils.getSymbol(connection, tokenAddress, state),
            VaultTokenUtils.rootOwnerAddress(connection, tokenAddress, state),
            VaultTokenUtils.totalSupply(connection, tokenAddress, state),
        ]).then(async ([decimals, name, symbol, rootOwnerAddress, totalSupply]) => {
            if (process.env.NODE_ENV !== 'production') {
                const providerState = await connection.getProviderState();
                const tokenLink = getScanLink(tokenAddress.toString(), providerState.networkId.toString());
                const ownerLink = getScanLink(rootOwnerAddress.toString(), providerState.networkId.toString());
                const args = [
                    `%cVaultTokenUtils%c Request token %c${symbol}%c [%c${sliceString(tokenAddress.toString())}%c] details${cachedState ? ' [from cache]' : ''}`,
                    successLabelStyle,
                    inheritTextStyle,
                    successTextStyle,
                    inheritTextStyle,
                    successTextStyle,
                    inheritTextStyle,
                ];
                groupCollapsed(...args);
                debug(`Token root address: %c${sliceString(tokenAddress.toString())}%c ${tokenLink}`, successTextStyle, inheritTextStyle);
                debug(`Token symbol: %c${symbol}`, successTextStyle);
                debug(`Token name: %c${name}`, successTextStyle);
                debug(`Token decimals: %c${decimals}`, successTextStyle);
                debug(`Token total supply: %c${formattedTokenAmount(totalSupply, decimals, {
                    preserve: true,
                    roundOn: false,
                })}`, successTextStyle);
                debug(`Token root owner address: %c${sliceString(rootOwnerAddress.toString())}%c ${ownerLink}`, successTextStyle, inheritTextStyle);
                groupEnd();
            }
            return {
                address: resolveTvmAddress(tokenAddress),
                contractState: state,
                decimals,
                name,
                rootOwnerAddress,
                symbol,
                totalSupply,
            };
        });
    }
    static async getDecimals(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.decimals({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return parseInt(result.value0, 10);
    }
    static async getSymbol(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.symbol({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async getName(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.name({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async rootOwnerAddress(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.rootOwner({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async totalSupply(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.totalSupply({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async burnPaused(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.burnPaused({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async burnByRootDisabled(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.burnByRootDisabled({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async mintDisabled(connection, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, tokenAddress);
        const result = await vaultTokenRootContract(connection, tokenAddress)
            .methods.mintDisabled({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    /**
     * Returns expected token wallet address
     * @param {ProviderRpcClient} connection
     * @param {VaultTokenOwnerAbiParams} params
     * @param {FullContractState} [cachedState]
     * @returns Promise<Address>
     */
    static async walletOf(connection, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, params.tokenAddress);
        const result = await vaultTokenRootContract(connection, params.tokenAddress)
            .methods.walletOf({
            answerId: 0,
            walletOwner: resolveTvmAddress(params.ownerAddress),
        })
            .call({ cachedState: state, responsible: true });
        if (process.env.NODE_ENV !== 'production') {
            const providerState = await connection.getProviderState();
            const tokenLink = getScanLink(params.tokenAddress.toString(), providerState.networkId.toString());
            const ownerLink = getScanLink(params.ownerAddress.toString(), providerState.networkId.toString());
            const walletLink = getScanLink(result.value0.toString(), providerState.networkId.toString());
            const symbol = cachedState
                ? await VaultTokenUtils.getSymbol(connection, params.tokenAddress, cachedState)
                : undefined;
            groupCollapsed(`%cVaultTokenUtils%c Request wallet address in token %c${symbol ?? sliceString(params.tokenAddress.toString())}%c${cachedState
                ? ' [from cache]'
                : ''}`, successLabelStyle, inheritTextStyle, successTextStyle, inheritTextStyle);
            debug(`Token root address: %c${sliceString(params.tokenAddress.toString())}%c ${tokenLink}`, successTextStyle, inheritTextStyle);
            debug(`Owner address: %c${sliceString(params.ownerAddress.toString())}%c ${ownerLink}`, successTextStyle, inheritTextStyle);
            debug(`Wallet address: %c${sliceString(result.value0.toString())}%c ${walletLink}`, successTextStyle, inheritTextStyle);
            groupEnd();
        }
        return result.value0;
    }
}