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

MobX-based JavaScript Core library

import { debug, groupCollapsed, groupEnd, sliceAddress } from '@broxus/js-utils';
import { getScanLink, inheritTextStyle, successLabelStyle, successTextStyle } from '../../console';
import { DEFAULT_NATIVE_CURRENCY_DECIMALS } from '../../constants';
import { TvmToken } from '../../models/tvm-token';
import { vaultTokenWalletContract } from '../../models/vault-token-wallet/contracts';
import { getFullContractState, resolveTvmAddress, toInt } from '../../utils';
export class VaultTokenWalletUtils {
    /**
     * Accept native - makes the transaction via token wallet contract to send message
     * @param {ProviderRpcClient} provider
     * @param {Address | string} tokenWalletAddress
     * @param {VaultTokenWalletAcceptNativeAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     */
    static async acceptNative(provider, tokenWalletAddress, params, args) {
        return vaultTokenWalletContract(provider, tokenWalletAddress)
            .methods.acceptNative({
            amount: params.amount,
            deployWalletValue: params.deployWalletValue || 0,
            payload: params.payload || '',
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(0.5, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    /**
     * Transfer - makes the transaction via token wallet contract to send message
     * @param {ProviderRpcClient} provider
     * @param {Address | string} tokenWalletAddress
     * @param {VaultTokenWalletTransferAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     */
    static async transfer(provider, tokenWalletAddress, params, args) {
        return vaultTokenWalletContract(provider, tokenWalletAddress)
            .methods.transfer({
            amount: params.amount,
            deployWalletValue: params.deployWalletValue || 0,
            notify: params.notify ?? true,
            payload: params.payload || '',
            recipient: resolveTvmAddress(params.recipient),
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(0.5, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    /**
     * Transfer to wallet - makes the transaction via token wallet contract to send message to a
     * token wallet
     * @param {ProviderRpcClient} provider
     * @param {Address | string} tokenWalletAddress
     * @param {VaultTokenWalletTransferToWalletAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     */
    static async transferToWallet(provider, tokenWalletAddress, params, args) {
        return vaultTokenWalletContract(provider, tokenWalletAddress)
            .methods.transferToWallet({
            amount: params.amount,
            notify: params.notify ?? true,
            payload: params.payload || '',
            recipientTokenWallet: resolveTvmAddress(params.recipientTokenWallet),
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(0.5, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    /**
     * Burns assets in favor of the address specified in callbackTo
     * @param {ProviderRpcClient} provider
     * @param {Address | string} tokenWalletAddress
     * @param {VaultTokenWalletBurnAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     */
    static async burn(provider, tokenWalletAddress, params, args) {
        return vaultTokenWalletContract(provider, tokenWalletAddress)
            .methods.burn({
            amount: params.amount,
            callbackTo: resolveTvmAddress(params.callbackTo),
            payload: params.payload || '',
            remainingGasTo: resolveTvmAddress(params.remainingGasTo),
        })
            .sendDelayed({
            amount: toInt(0.2, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    /**
     * Destroy wallet
     * @param {ProviderRpcClient} provider
     * @param {Address | string} tokenWalletAddress
     * @param {VaultTokenWalletDestroyAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     */
    static async destroy(provider, tokenWalletAddress, params, args) {
        return vaultTokenWalletContract(provider, tokenWalletAddress)
            .methods.destroy({ remainingGasTo: resolveTvmAddress(params.remainingGasTo) })
            .sendDelayed({
            amount: toInt(0.01, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.remainingGasTo),
            ...args,
        });
    }
    /**
     * Returns token wallet balance in this token by the given token root address
     * and owner wallet address or owner token wallet address.
     * @param {VaultTokenOwnerAbiParams | VaultTokenWalletAddressAbiParams} params
     * @param {FullContractState} [cachedState]
     * @param {ProviderRpcClient} [connection]
     */
    static async balance(connection, params, cachedState) {
        let tokenWalletAddress;
        if ('walletAddress' in params) {
            tokenWalletAddress = params.walletAddress;
        }
        else if ('tokenAddress' in params && 'ownerAddress' in params) {
            tokenWalletAddress = await TvmToken.Utils.walletOf(connection, params);
        }
        // @ts-ignore
        if (tokenWalletAddress == null) {
            throw new Error('Token Wallet not specified');
        }
        const state = cachedState ?? (await getFullContractState(connection, tokenWalletAddress));
        return vaultTokenWalletContract(connection, tokenWalletAddress)
            .methods.balance({ answerId: 0 })
            .call({ cachedState: state, responsible: true })
            .then(async (result) => {
            if (process.env.NODE_ENV !== 'production') {
                const tokenRootAddress = 'tokenAddress' in params
                    ? params.tokenAddress.toString()
                    : (await VaultTokenWalletUtils.root(connection, tokenWalletAddress, state))?.toString();
                const walletOwnerAddress = 'ownerAddress' in params
                    ? params.ownerAddress.toString()
                    : (await VaultTokenWalletUtils.owner(connection, tokenWalletAddress, state))?.toString();
                groupCollapsed(`%cVaultTokenWalletUtils%c Request token wallet [%c${sliceAddress(tokenWalletAddress.toString())}%c] balance${cachedState ? ' [from cache]' : ''}`, successLabelStyle, inheritTextStyle, successTextStyle, inheritTextStyle);
                debug(`Token address: %c${sliceAddress(tokenRootAddress)}%c ${getScanLink(tokenRootAddress ?? '')}`, successTextStyle, inheritTextStyle);
                debug(`Owner address: %c${sliceAddress(walletOwnerAddress)}%c ${getScanLink(walletOwnerAddress ?? '')}`, successTextStyle, inheritTextStyle);
                debug(`Wallet address: %c${sliceAddress(tokenWalletAddress.toString())}%c ${getScanLink(tokenWalletAddress.toString())}`, successTextStyle, inheritTextStyle);
                debug(`Balance: %c${result.value0}`, successTextStyle);
                groupEnd();
            }
            return result.value0;
        })
            .catch(() => undefined);
    }
    static async owner(connection, tokenWalletAddress, cachedState) {
        try {
            const state = cachedState ?? await getFullContractState(connection, tokenWalletAddress);
            const result = await vaultTokenWalletContract(connection, tokenWalletAddress)
                .methods.owner({ answerId: 0 })
                .call({ cachedState: state, responsible: true });
            return result.value0;
        }
        catch {
            return undefined;
        }
    }
    static async root(connection, tokenWalletAddress, cachedState) {
        try {
            const state = cachedState ?? await getFullContractState(connection, tokenWalletAddress);
            const result = await vaultTokenWalletContract(connection, tokenWalletAddress)
                .methods.root({ answerId: 0 })
                .call({ cachedState: state, responsible: true });
            return result.value0;
        }
        catch {
            return undefined;
        }
    }
}