"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.approve = approve;
exports.approveSync = approveSync;
exports.burnBlocked = burnBlocked;
exports.burnBlockedSync = burnBlockedSync;
exports.burn = burn;
exports.burnSync = burnSync;
exports.changeTransferPolicy = changeTransferPolicy;
exports.changeTransferPolicySync = changeTransferPolicySync;
exports.create = create;
exports.createSync = createSync;
exports.getAllowance = getAllowance;
exports.getBalance = getBalance;
exports.getMetadata = getMetadata;
exports.getTotalSupply = getTotalSupply;
exports.getRoleAdmin = getRoleAdmin;
exports.hasRole = hasRole;
exports.grantRoles = grantRoles;
exports.grantRolesSync = grantRolesSync;
exports.mint = mint;
exports.mintSync = mintSync;
exports.pause = pause;
exports.pauseSync = pauseSync;
exports.renounceRoles = renounceRoles;
exports.renounceRolesSync = renounceRolesSync;
exports.revokeRoles = revokeRoles;
exports.revokeRolesSync = revokeRolesSync;
exports.setSupplyCap = setSupplyCap;
exports.setSupplyCapSync = setSupplyCapSync;
exports.setRoleAdmin = setRoleAdmin;
exports.setRoleAdminSync = setRoleAdminSync;
exports.transfer = transfer;
exports.transferSync = transferSync;
exports.unpause = unpause;
exports.unpauseSync = unpauseSync;
exports.prepareUpdateQuoteToken = prepareUpdateQuoteToken;
exports.prepareUpdateQuoteTokenSync = prepareUpdateQuoteTokenSync;
exports.updateQuoteToken = updateQuoteToken;
exports.updateQuoteTokenSync = updateQuoteTokenSync;
exports.watchApprove = watchApprove;
exports.watchBurn = watchBurn;
exports.watchCreate = watchCreate;
exports.watchMint = watchMint;
exports.watchAdminRole = watchAdminRole;
exports.watchRole = watchRole;
exports.watchTransfer = watchTransfer;
exports.watchUpdateQuoteToken = watchUpdateQuoteToken;
const Hex = require("ox/Hex");
const tempo_1 = require("ox/tempo");
const parseAccount_js_1 = require("../../accounts/utils/parseAccount.js");
const estimateContractGas_js_1 = require("../../actions/public/estimateContractGas.js");
const multicall_js_1 = require("../../actions/public/multicall.js");
const readContract_js_1 = require("../../actions/public/readContract.js");
const simulateContract_js_1 = require("../../actions/public/simulateContract.js");
const watchContractEvent_js_1 = require("../../actions/public/watchContractEvent.js");
const internal_Token = require("../../actions/token/internal.js");
const sendTransaction_js_1 = require("../../actions/wallet/sendTransaction.js");
const sendTransactionSync_js_1 = require("../../actions/wallet/sendTransactionSync.js");
const writeContract_js_1 = require("../../actions/wallet/writeContract.js");
const writeContractSync_js_1 = require("../../actions/wallet/writeContractSync.js");
const account_js_1 = require("../../errors/account.js");
const encodeFunctionData_js_1 = require("../../utils/abi/encodeFunctionData.js");
const parseEventLogs_js_1 = require("../../utils/abi/parseEventLogs.js");
const formatUnits_js_1 = require("../../utils/unit/formatUnits.js");
const Abis = require("../Abis.js");
const Addresses = require("../Addresses.js");
const utils_js_1 = require("../internal/utils.js");
async function approve(client, parameters) {
    return approve.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (approve) {
    async function inner(action, client, parameters) {
        return (await action(client, {
            ...parameters,
            ...approve.call(client, parameters),
        }));
    }
    approve.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { amount, spender, token } = args;
        const { address, decimals } = (0, utils_js_1.resolveToken)(client, { token });
        return (0, utils_js_1.defineCall)({
            address,
            abi: Abis.tip20,
            functionName: 'approve',
            args: [spender, internal_Token.toBaseUnits(amount, decimals)],
        });
    }
    approve.call = call;
    async function estimateGas(client, parameters) {
        return (0, estimateContractGas_js_1.estimateContractGas)(client, {
            ...(0, utils_js_1.pickWriteParameters)(parameters),
            ...approve.call(client, parameters),
        });
    }
    approve.estimateGas = estimateGas;
    async function simulate(client, parameters) {
        return (0, simulateContract_js_1.simulateContract)(client, {
            ...(0, utils_js_1.pickWriteParameters)(parameters),
            ...approve.call(client, parameters),
        });
    }
    approve.simulate = simulate;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'Approval',
        });
        if (!log)
            throw new Error('`Approval` event not found.');
        return log;
    }
    approve.extractEvent = extractEvent;
})(approve || (exports.approve = approve = {}));
async function approveSync(client, parameters) {
    const { amount, token, throwOnReceiptRevert = true } = parameters;
    const { decimals } = (0, utils_js_1.resolveToken)(client, { token });
    const resolved = internal_Token.resolveAmountDecimals(amount, decimals);
    const receipt = await approve.inner(writeContractSync_js_1.writeContractSync, client, {
        ...parameters,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = approve.extractEvent(receipt.logs);
    return {
        ...args,
        ...(resolved === undefined
            ? {}
            : { decimals: resolved, formatted: (0, formatUnits_js_1.formatUnits)(args.amount, resolved) }),
        receipt,
    };
}
async function burnBlocked(client, parameters) {
    return burnBlocked.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (burnBlocked) {
    async function inner(action, client, parameters) {
        const { amount, from, token, ...rest } = parameters;
        const call = burnBlocked.call(client, { amount, from, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    burnBlocked.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { from, amount, token } = args;
        const { address, decimals } = (0, utils_js_1.resolveToken)(client, { token });
        return (0, utils_js_1.defineCall)({
            address,
            abi: Abis.tip20,
            functionName: 'burnBlocked',
            args: [from, internal_Token.toBaseUnits(amount, decimals)],
        });
    }
    burnBlocked.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'BurnBlocked',
        });
        if (!log)
            throw new Error('`BurnBlocked` event not found.');
        return log;
    }
    burnBlocked.extractEvent = extractEvent;
})(burnBlocked || (exports.burnBlocked = burnBlocked = {}));
async function burnBlockedSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await burnBlocked.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = burnBlocked.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function burn(client, parameters) {
    return burn.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (burn) {
    async function inner(action, client, parameters) {
        const { amount, memo, token, ...rest } = parameters;
        const call = burn.call(client, { amount, memo, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    burn.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { amount, memo, token } = args;
        const { address, decimals } = (0, utils_js_1.resolveToken)(client, { token });
        const value = internal_Token.toBaseUnits(amount, decimals);
        const callArgs = memo
            ? {
                functionName: 'burnWithMemo',
                args: [value, Hex.padLeft(memo, 32)],
            }
            : {
                functionName: 'burn',
                args: [value],
            };
        return (0, utils_js_1.defineCall)({
            address,
            abi: Abis.tip20,
            ...callArgs,
        });
    }
    burn.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'Burn',
        });
        if (!log)
            throw new Error('`Burn` event not found.');
        return log;
    }
    burn.extractEvent = extractEvent;
})(burn || (exports.burn = burn = {}));
async function burnSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await burn.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = burn.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function changeTransferPolicy(client, parameters) {
    return changeTransferPolicy.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (changeTransferPolicy) {
    async function inner(action, client, parameters) {
        const { policyId, token, ...rest } = parameters;
        const call = changeTransferPolicy.call(client, { policyId, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    changeTransferPolicy.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, policyId } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'changeTransferPolicyId',
            args: [policyId],
        });
    }
    changeTransferPolicy.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'TransferPolicyUpdate',
        });
        if (!log)
            throw new Error('`TransferPolicyUpdate` event not found.');
        return log;
    }
    changeTransferPolicy.extractEvent = extractEvent;
})(changeTransferPolicy || (exports.changeTransferPolicy = changeTransferPolicy = {}));
async function changeTransferPolicySync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await changeTransferPolicy.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = changeTransferPolicy.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function create(client, parameters) {
    return create.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (create) {
    async function inner(action, client, parameters) {
        const { account = client.account, admin: admin_ = client.account, chain = client.chain, ...rest } = parameters;
        const admin = admin_ ? (0, parseAccount_js_1.parseAccount)(admin_) : undefined;
        if (!admin)
            throw new Error('admin is required.');
        const call = create.call(client, { ...rest, admin: admin.address });
        return (await action(client, {
            ...parameters,
            account,
            chain,
            ...call,
        }));
    }
    create.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { name, symbol, currency, logoURI, quoteToken = Addresses.pathUsd, admin, salt = Hex.random(32), } = args;
        return (0, utils_js_1.defineCall)({
            address: Addresses.tip20Factory,
            abi: Abis.tip20Factory,
            args: typeof logoURI === 'string'
                ? [
                    name,
                    symbol,
                    currency,
                    (0, utils_js_1.resolveToken)(client, { token: quoteToken }).address,
                    admin,
                    salt,
                    logoURI,
                ]
                : [
                    name,
                    symbol,
                    currency,
                    (0, utils_js_1.resolveToken)(client, { token: quoteToken }).address,
                    admin,
                    salt,
                ],
            functionName: 'createToken',
        });
    }
    create.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20Factory,
            logs,
            eventName: 'TokenCreated',
            strict: true,
        });
        if (!log)
            throw new Error('`TokenCreated` event not found.');
        return log;
    }
    create.extractEvent = extractEvent;
})(create || (exports.create = create = {}));
async function createSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await create.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = create.extractEvent(receipt.logs);
    const tokenId = tempo_1.TokenId.fromAddress(args.token);
    return {
        ...args,
        receipt,
        tokenId,
    };
}
async function getAllowance(client, parameters) {
    const { account, decimals, spender, token, ...rest } = parameters;
    const [amount, { decimals: resolved }] = await Promise.all([
        (0, readContract_js_1.readContract)(client, {
            ...rest,
            ...getAllowance.call(client, { account, spender, token }),
        }),
        (0, utils_js_1.resolveTokenWithDecimals)(client, {
            decimals,
            token,
        }),
    ]);
    return internal_Token.toAmount(amount, resolved);
}
(function (getAllowance) {
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, args).address,
            abi: Abis.tip20,
            functionName: 'allowance',
            args: [args.account, args.spender],
        });
    }
    getAllowance.call = call;
})(getAllowance || (exports.getAllowance = getAllowance = {}));
async function getBalance(client, parameters) {
    const { account: account_ = client.account, decimals, token, ...rest } = parameters;
    if (!account_)
        throw new account_js_1.AccountNotFoundError();
    const account = (0, parseAccount_js_1.parseAccount)(account_).address;
    const [amount, { decimals: resolved }] = await Promise.all([
        (0, readContract_js_1.readContract)(client, {
            ...rest,
            ...getBalance.call(client, { account, token }),
        }),
        (0, utils_js_1.resolveTokenWithDecimals)(client, {
            decimals,
            token,
        }),
    ]);
    return internal_Token.toAmount(amount, resolved);
}
(function (getBalance) {
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const account_ = args.account ?? client?.account;
        if (!account_)
            throw new account_js_1.AccountNotFoundError();
        const account = (0, parseAccount_js_1.parseAccount)(account_).address;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, args).address,
            abi: Abis.tip20,
            functionName: 'balanceOf',
            args: [account],
        });
    }
    getBalance.call = call;
})(getBalance || (exports.getBalance = getBalance = {}));
async function getMetadata(client, parameters) {
    const { token, ...rest } = parameters;
    const { address } = (0, utils_js_1.resolveToken)(client, { token });
    const abi = Abis.tip20;
    const declared = (0, utils_js_1.findDeclaredToken)(client, token);
    const overrides = {
        ...(declared?.decimals != null ? { decimals: declared.decimals } : {}),
        ...(declared?.name != null ? { name: declared.name } : {}),
        ...(declared?.symbol != null ? { symbol: declared.symbol } : {}),
    };
    if (tempo_1.TokenId.fromAddress(address) === tempo_1.TokenId.fromAddress(Addresses.pathUsd))
        return readMetadataContracts(client, {
            ...rest,
            contracts: [
                {
                    address,
                    abi,
                    functionName: 'currency',
                },
                {
                    address,
                    abi,
                    functionName: 'decimals',
                },
                {
                    address,
                    abi,
                    functionName: 'logoURI',
                },
                {
                    address,
                    abi,
                    functionName: 'name',
                },
                {
                    address,
                    abi,
                    functionName: 'symbol',
                },
                {
                    address,
                    abi,
                    functionName: 'totalSupply',
                },
            ],
        }).then(([currency, decimals, logoURI, name, symbol, totalSupply]) => ({
            name: unwrapMulticallResult(name),
            symbol: unwrapMulticallResult(symbol),
            currency: unwrapMulticallResult(currency),
            decimals: unwrapMulticallResult(decimals),
            logoURI: unwrapMulticallResult(logoURI, ''),
            totalSupply: unwrapMulticallResult(totalSupply),
            ...overrides,
        }));
    return readMetadataContracts(client, {
        ...rest,
        contracts: [
            {
                address,
                abi,
                functionName: 'currency',
            },
            {
                address,
                abi,
                functionName: 'decimals',
            },
            {
                address,
                abi,
                functionName: 'logoURI',
            },
            {
                address,
                abi,
                functionName: 'quoteToken',
            },
            {
                address,
                abi,
                functionName: 'name',
            },
            {
                address,
                abi,
                functionName: 'paused',
            },
            {
                address,
                abi,
                functionName: 'supplyCap',
            },
            {
                address,
                abi,
                functionName: 'symbol',
            },
            {
                address,
                abi,
                functionName: 'totalSupply',
            },
            {
                address,
                abi,
                functionName: 'transferPolicyId',
            },
        ],
    }).then(([currency, decimals, logoURI, quoteToken, name, paused, supplyCap, symbol, totalSupply, transferPolicyId,]) => ({
        name: unwrapMulticallResult(name),
        symbol: unwrapMulticallResult(symbol),
        currency: unwrapMulticallResult(currency),
        decimals: unwrapMulticallResult(decimals),
        logoURI: unwrapMulticallResult(logoURI, ''),
        quoteToken: unwrapMulticallResult(quoteToken),
        totalSupply: unwrapMulticallResult(totalSupply),
        paused: unwrapMulticallResult(paused),
        supplyCap: unwrapMulticallResult(supplyCap),
        transferPolicyId: unwrapMulticallResult(transferPolicyId),
        ...overrides,
    }));
}
async function readMetadataContracts(client, parameters) {
    if (client.batch?.multicall === undefined)
        return (0, multicall_js_1.multicall)(client, {
            ...parameters,
            allowFailure: true,
            deployless: true,
        });
    const { contracts, ...rest } = parameters;
    const results = await Promise.allSettled(contracts.map((contract) => (0, readContract_js_1.readContract)(client, {
        ...rest,
        ...contract,
    })));
    return results.map((result) => result.status === 'fulfilled'
        ? { result: result.value, status: 'success' }
        : { error: result.reason, status: 'failure' });
}
function unwrapMulticallResult(response, ...fallback) {
    if (response.status === 'failure') {
        if (fallback.length > 0)
            return fallback[0];
        throw response.error;
    }
    return response.result;
}
async function getTotalSupply(client, parameters) {
    const { decimals, token, ...rest } = parameters;
    const [amount, { decimals: resolved }] = await Promise.all([
        (0, readContract_js_1.readContract)(client, {
            ...rest,
            ...getTotalSupply.call(client, { token }),
        }),
        (0, utils_js_1.resolveTokenWithDecimals)(client, {
            decimals,
            token,
        }),
    ]);
    return internal_Token.toAmount(amount, resolved);
}
(function (getTotalSupply) {
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, args).address,
            abi: Abis.tip20,
            args: [],
            functionName: 'totalSupply',
        });
    }
    getTotalSupply.call = call;
})(getTotalSupply || (exports.getTotalSupply = getTotalSupply = {}));
async function getRoleAdmin(client, parameters) {
    return (0, readContract_js_1.readContract)(client, {
        ...parameters,
        ...getRoleAdmin.call(client, parameters),
    });
}
(function (getRoleAdmin) {
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { role, token } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'getRoleAdmin',
            args: [tempo_1.TokenRole.serialize(role)],
        });
    }
    getRoleAdmin.call = call;
})(getRoleAdmin || (exports.getRoleAdmin = getRoleAdmin = {}));
async function hasRole(client, parameters) {
    const { account = client.account } = parameters;
    const address = account ? (0, parseAccount_js_1.parseAccount)(account).address : undefined;
    if (!address)
        throw new Error('account is required.');
    return (0, readContract_js_1.readContract)(client, {
        ...parameters,
        ...hasRole.call(client, { ...parameters, account: address }),
    });
}
(function (hasRole) {
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { account, role, token } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'hasRole',
            args: [account, tempo_1.TokenRole.serialize(role)],
        });
    }
    hasRole.call = call;
})(hasRole || (exports.hasRole = hasRole = {}));
async function grantRoles(client, parameters) {
    return grantRoles.inner(sendTransaction_js_1.sendTransaction, client, parameters);
}
(function (grantRoles) {
    async function inner(action, client, parameters) {
        return (await action(client, {
            ...parameters,
            calls: parameters.roles.map((role) => {
                const call = grantRoles.call(client, { ...parameters, role });
                return {
                    ...call,
                    data: (0, encodeFunctionData_js_1.encodeFunctionData)(call),
                };
            }),
        }));
    }
    grantRoles.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, to, role } = args;
        const roleHash = tempo_1.TokenRole.serialize(role);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'grantRole',
            args: [roleHash, to],
        });
    }
    grantRoles.call = call;
    function extractEvents(logs) {
        const events = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'RoleMembershipUpdated',
        });
        if (events.length === 0)
            throw new Error('`RoleMembershipUpdated` events not found.');
        return events;
    }
    grantRoles.extractEvents = extractEvents;
})(grantRoles || (exports.grantRoles = grantRoles = {}));
async function grantRolesSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await grantRoles.inner(sendTransactionSync_js_1.sendTransactionSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const events = grantRoles.extractEvents(receipt.logs);
    const value = events.map((event) => event.args);
    return {
        receipt,
        value,
    };
}
async function mint(client, parameters) {
    return mint.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (mint) {
    async function inner(action, client, parameters) {
        const { amount, memo, to, token, ...rest } = parameters;
        const call = mint.call(client, { amount, memo, to, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    mint.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { to, amount, memo, token } = args;
        const { address, decimals } = (0, utils_js_1.resolveToken)(client, { token });
        const value = internal_Token.toBaseUnits(amount, decimals);
        const callArgs = memo
            ? {
                functionName: 'mintWithMemo',
                args: [to, value, Hex.padLeft(memo, 32)],
            }
            : {
                functionName: 'mint',
                args: [to, value],
            };
        return (0, utils_js_1.defineCall)({
            address,
            abi: Abis.tip20,
            ...callArgs,
        });
    }
    mint.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'Mint',
        });
        if (!log)
            throw new Error('`Mint` event not found.');
        return log;
    }
    mint.extractEvent = extractEvent;
})(mint || (exports.mint = mint = {}));
async function mintSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await mint.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = mint.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function pause(client, parameters) {
    return pause.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (pause) {
    async function inner(action, client, parameters) {
        const { token, ...rest } = parameters;
        const call = pause.call(client, { token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    pause.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'pause',
            args: [],
        });
    }
    pause.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'PauseStateUpdate',
        });
        if (!log)
            throw new Error('`PauseStateUpdate` event not found.');
        return log;
    }
    pause.extractEvent = extractEvent;
})(pause || (exports.pause = pause = {}));
async function pauseSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await pause.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = pause.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function renounceRoles(client, parameters) {
    return renounceRoles.inner(sendTransaction_js_1.sendTransaction, client, parameters);
}
(function (renounceRoles) {
    async function inner(action, client, parameters) {
        return (await action(client, {
            ...parameters,
            calls: parameters.roles.map((role) => {
                const call = renounceRoles.call(client, { ...parameters, role });
                return {
                    ...call,
                    data: (0, encodeFunctionData_js_1.encodeFunctionData)(call),
                };
            }),
        }));
    }
    renounceRoles.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, role } = args;
        const roleHash = tempo_1.TokenRole.serialize(role);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'renounceRole',
            args: [roleHash],
        });
    }
    renounceRoles.call = call;
    function extractEvents(logs) {
        const events = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'RoleMembershipUpdated',
        });
        if (events.length === 0)
            throw new Error('`RoleMembershipUpdated` events not found.');
        return events;
    }
    renounceRoles.extractEvents = extractEvents;
})(renounceRoles || (exports.renounceRoles = renounceRoles = {}));
async function renounceRolesSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await renounceRoles.inner(sendTransactionSync_js_1.sendTransactionSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const events = renounceRoles.extractEvents(receipt.logs);
    const value = events.map((event) => event.args);
    return {
        receipt,
        value,
    };
}
async function revokeRoles(client, parameters) {
    return revokeRoles.inner(sendTransaction_js_1.sendTransaction, client, parameters);
}
(function (revokeRoles) {
    async function inner(action, client, parameters) {
        const { from: _, ...rest } = parameters;
        return (await action(client, {
            ...rest,
            calls: parameters.roles.map((role) => {
                const call = revokeRoles.call(client, { ...parameters, role });
                return {
                    ...call,
                    data: (0, encodeFunctionData_js_1.encodeFunctionData)(call),
                };
            }),
        }));
    }
    revokeRoles.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, from, role } = args;
        const roleHash = tempo_1.TokenRole.serialize(role);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'revokeRole',
            args: [roleHash, from],
        });
    }
    revokeRoles.call = call;
    function extractEvents(logs) {
        const events = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'RoleMembershipUpdated',
        });
        if (events.length === 0)
            throw new Error('`RoleMembershipUpdated` events not found.');
        return events;
    }
    revokeRoles.extractEvents = extractEvents;
})(revokeRoles || (exports.revokeRoles = revokeRoles = {}));
async function revokeRolesSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await revokeRoles.inner(sendTransactionSync_js_1.sendTransactionSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const events = revokeRoles.extractEvents(receipt.logs);
    const value = events.map((event) => event.args);
    return {
        receipt,
        value,
    };
}
async function setSupplyCap(client, parameters) {
    return setSupplyCap.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (setSupplyCap) {
    async function inner(action, client, parameters) {
        const { supplyCap, token, ...rest } = parameters;
        const call = setSupplyCap.call(client, { supplyCap, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    setSupplyCap.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, supplyCap } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'setSupplyCap',
            args: [supplyCap],
        });
    }
    setSupplyCap.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'SupplyCapUpdate',
        });
        if (!log)
            throw new Error('`SupplyCapUpdate` event not found.');
        return log;
    }
    setSupplyCap.extractEvent = extractEvent;
})(setSupplyCap || (exports.setSupplyCap = setSupplyCap = {}));
async function setSupplyCapSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await setSupplyCap.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = setSupplyCap.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function setRoleAdmin(client, parameters) {
    return setRoleAdmin.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (setRoleAdmin) {
    async function inner(action, client, parameters) {
        const { adminRole, role, token, ...rest } = parameters;
        const call = setRoleAdmin.call(client, { adminRole, role, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    setRoleAdmin.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, role, adminRole } = args;
        const roleHash = tempo_1.TokenRole.serialize(role);
        const adminRoleHash = tempo_1.TokenRole.serialize(adminRole);
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'setRoleAdmin',
            args: [roleHash, adminRoleHash],
        });
    }
    setRoleAdmin.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'RoleAdminUpdated',
        });
        if (!log)
            throw new Error('`RoleAdminUpdated` event not found.');
        return log;
    }
    setRoleAdmin.extractEvent = extractEvent;
})(setRoleAdmin || (exports.setRoleAdmin = setRoleAdmin = {}));
async function setRoleAdminSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await setRoleAdmin.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = setRoleAdmin.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function transfer(client, parameters) {
    return transfer.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (transfer) {
    async function inner(action, client, parameters) {
        return (await action(client, {
            ...parameters,
            ...transfer.call(client, parameters),
        }));
    }
    transfer.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { from, memo, to, token } = args;
        const { address, decimals } = (0, utils_js_1.resolveToken)(client, { token });
        const value = internal_Token.toBaseUnits(args.amount, decimals);
        const callArgs = (() => {
            if (memo && from)
                return {
                    functionName: 'transferFromWithMemo',
                    args: [from, to, value, Hex.padLeft(memo, 32)],
                };
            if (memo)
                return {
                    functionName: 'transferWithMemo',
                    args: [to, value, Hex.padLeft(memo, 32)],
                };
            if (from)
                return {
                    functionName: 'transferFrom',
                    args: [from, to, value],
                };
            return {
                functionName: 'transfer',
                args: [to, value],
            };
        })();
        return (0, utils_js_1.defineCall)({
            address,
            abi: Abis.tip20,
            ...callArgs,
        });
    }
    transfer.call = call;
    async function estimateGas(client, parameters) {
        return (0, estimateContractGas_js_1.estimateContractGas)(client, {
            ...(0, utils_js_1.pickWriteParameters)(parameters),
            ...transfer.call(client, parameters),
        });
    }
    transfer.estimateGas = estimateGas;
    async function simulate(client, parameters) {
        return (0, simulateContract_js_1.simulateContract)(client, {
            ...(0, utils_js_1.pickWriteParameters)(parameters),
            ...transfer.call(client, parameters),
        });
    }
    transfer.simulate = simulate;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'Transfer',
        });
        if (!log)
            throw new Error('`Transfer` event not found.');
        return log;
    }
    transfer.extractEvent = extractEvent;
})(transfer || (exports.transfer = transfer = {}));
async function transferSync(client, parameters) {
    const { amount, token, throwOnReceiptRevert = true } = parameters;
    const { decimals } = (0, utils_js_1.resolveToken)(client, { token });
    const resolved = internal_Token.resolveAmountDecimals(amount, decimals);
    const receipt = await transfer.inner(writeContractSync_js_1.writeContractSync, client, {
        ...parameters,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = transfer.extractEvent(receipt.logs);
    return {
        ...args,
        ...(resolved === undefined
            ? {}
            : { decimals: resolved, formatted: (0, formatUnits_js_1.formatUnits)(args.amount, resolved) }),
        receipt,
    };
}
async function unpause(client, parameters) {
    return unpause.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (unpause) {
    async function inner(action, client, parameters) {
        const { token, ...rest } = parameters;
        const call = unpause.call(client, { token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    unpause.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'unpause',
            args: [],
        });
    }
    unpause.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'PauseStateUpdate',
        });
        if (!log)
            throw new Error('`PauseStateUpdate` event not found.');
        return log;
    }
    unpause.extractEvent = extractEvent;
})(unpause || (exports.unpause = unpause = {}));
async function unpauseSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await unpause.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = unpause.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function prepareUpdateQuoteToken(client, parameters) {
    return prepareUpdateQuoteToken.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (prepareUpdateQuoteToken) {
    async function inner(action, client, parameters) {
        const { quoteToken, token, ...rest } = parameters;
        const call = prepareUpdateQuoteToken.call(client, { quoteToken, token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    prepareUpdateQuoteToken.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token, quoteToken } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'setNextQuoteToken',
            args: [(0, utils_js_1.resolveToken)(client, { token: quoteToken }).address],
        });
    }
    prepareUpdateQuoteToken.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'NextQuoteTokenSet',
        });
        if (!log)
            throw new Error('`NextQuoteTokenSet` event not found.');
        return log;
    }
    prepareUpdateQuoteToken.extractEvent = extractEvent;
})(prepareUpdateQuoteToken || (exports.prepareUpdateQuoteToken = prepareUpdateQuoteToken = {}));
async function prepareUpdateQuoteTokenSync(client, parameters) {
    const receipt = await prepareUpdateQuoteToken.inner(writeContractSync_js_1.writeContractSync, client, parameters);
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = prepareUpdateQuoteToken.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
async function updateQuoteToken(client, parameters) {
    return updateQuoteToken.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (updateQuoteToken) {
    async function inner(action, client, parameters) {
        const { token, ...rest } = parameters;
        const call = updateQuoteToken.call(client, { token });
        return (await action(client, {
            ...rest,
            ...call,
        }));
    }
    updateQuoteToken.inner = inner;
    function call(...parameters) {
        const [client, args] = (0, utils_js_1.resolveCallParameters)(parameters);
        const { token } = args;
        return (0, utils_js_1.defineCall)({
            address: (0, utils_js_1.resolveToken)(client, { token }).address,
            abi: Abis.tip20,
            functionName: 'completeQuoteTokenUpdate',
            args: [],
        });
    }
    updateQuoteToken.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.tip20,
            logs,
            eventName: 'QuoteTokenUpdate',
        });
        if (!log)
            throw new Error('`QuoteTokenUpdateCompleted` event not found.');
        return log;
    }
    updateQuoteToken.extractEvent = extractEvent;
})(updateQuoteToken || (exports.updateQuoteToken = updateQuoteToken = {}));
async function updateQuoteTokenSync(client, parameters) {
    const receipt = await updateQuoteToken.inner(writeContractSync_js_1.writeContractSync, client, parameters);
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = updateQuoteToken.extractEvent(receipt.logs);
    return {
        ...args,
        receipt,
    };
}
function watchApprove(client, parameters) {
    const { onApproval, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'Approval',
        onLogs: (logs) => {
            for (const log of logs)
                onApproval(log.args, log);
        },
        strict: true,
    });
}
function watchBurn(client, parameters) {
    const { onBurn, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'Burn',
        onLogs: (logs) => {
            for (const log of logs)
                onBurn(log.args, log);
        },
        strict: true,
    });
}
function watchCreate(client, parameters) {
    const { onTokenCreated, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: Addresses.tip20Factory,
        abi: Abis.tip20Factory,
        eventName: 'TokenCreated',
        onLogs: (logs) => {
            for (const log of logs)
                onTokenCreated(log.args, log);
        },
        strict: true,
    });
}
function watchMint(client, parameters) {
    const { onMint, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'Mint',
        onLogs: (logs) => {
            for (const log of logs)
                onMint(log.args, log);
        },
        strict: true,
    });
}
function watchAdminRole(client, parameters) {
    const { onRoleAdminUpdated, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'RoleAdminUpdated',
        onLogs: (logs) => {
            for (const log of logs)
                onRoleAdminUpdated(log.args, log);
        },
        strict: true,
    });
}
function watchRole(client, parameters) {
    const { onRoleUpdated, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'RoleMembershipUpdated',
        onLogs: (logs) => {
            for (const log of logs) {
                const type = log.args.hasRole ? 'granted' : 'revoked';
                onRoleUpdated({ ...log.args, type }, log);
            }
        },
        strict: true,
    });
}
function watchTransfer(client, parameters) {
    const { onTransfer, token, ...rest } = parameters;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address: (0, utils_js_1.resolveToken)(client, { token }).address,
        abi: Abis.tip20,
        eventName: 'Transfer',
        onLogs: (logs) => {
            for (const log of logs)
                onTransfer(log.args, log);
        },
        strict: true,
    });
}
function watchUpdateQuoteToken(client, parameters) {
    const { onUpdateQuoteToken, token, ...rest } = parameters;
    const address = (0, utils_js_1.resolveToken)(client, { token }).address;
    return (0, watchContractEvent_js_1.watchContractEvent)(client, {
        ...rest,
        address,
        abi: Abis.tip20,
        onLogs: (logs) => {
            for (const log of logs) {
                if (log.eventName !== 'NextQuoteTokenSet' &&
                    log.eventName !== 'QuoteTokenUpdate')
                    continue;
                onUpdateQuoteToken({
                    ...log.args,
                    completed: log.eventName === 'QuoteTokenUpdate',
                }, log);
            }
        },
        strict: true,
    });
}
//# sourceMappingURL=token.js.map