viem/_cjs/tempo/Decorator.js

TypeScript Interface for Ethereum

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.decorator = decorator;
const ammActions = require("./actions/amm.js");
const dexActions = require("./actions/dex.js");
const faucetActions = require("./actions/faucet.js");
const feeActions = require("./actions/fee.js");
const policyActions = require("./actions/policy.js");
const rewardActions = require("./actions/reward.js");
const tokenActions = require("./actions/token.js");
function decorator() {
    return (client) => {
        return {
            amm: {
                getPool: (parameters) => ammActions.getPool(client, parameters),
                getLiquidityBalance: (parameters) => ammActions.getLiquidityBalance(client, parameters),
                burn: (parameters) => ammActions.burn(client, parameters),
                burnSync: (parameters) => ammActions.burnSync(client, parameters),
                mint: (parameters) => ammActions.mint(client, parameters),
                mintSync: (parameters) => ammActions.mintSync(client, parameters),
                rebalanceSwap: (parameters) => ammActions.rebalanceSwap(client, parameters),
                rebalanceSwapSync: (parameters) => ammActions.rebalanceSwapSync(client, parameters),
                watchBurn: (parameters) => ammActions.watchBurn(client, parameters),
                watchMint: (parameters) => ammActions.watchMint(client, parameters),
                watchRebalanceSwap: (parameters) => ammActions.watchRebalanceSwap(client, parameters),
            },
            dex: {
                buy: (parameters) => dexActions.buy(client, parameters),
                buySync: (parameters) => dexActions.buySync(client, parameters),
                cancel: (parameters) => dexActions.cancel(client, parameters),
                cancelSync: (parameters) => dexActions.cancelSync(client, parameters),
                cancelStale: (parameters) => dexActions.cancelStale(client, parameters),
                cancelStaleSync: (parameters) => dexActions.cancelStaleSync(client, parameters),
                createPair: (parameters) => dexActions.createPair(client, parameters),
                createPairSync: (parameters) => dexActions.createPairSync(client, parameters),
                getBalance: (parameters) => dexActions.getBalance(client, parameters),
                getBuyQuote: (parameters) => dexActions.getBuyQuote(client, parameters),
                getOrder: (parameters) => dexActions.getOrder(client, parameters),
                getTickLevel: (parameters) => dexActions.getTickLevel(client, parameters),
                getSellQuote: (parameters) => dexActions.getSellQuote(client, parameters),
                place: (parameters) => dexActions.place(client, parameters),
                placeSync: (parameters) => dexActions.placeSync(client, parameters),
                placeFlip: (parameters) => dexActions.placeFlip(client, parameters),
                placeFlipSync: (parameters) => dexActions.placeFlipSync(client, parameters),
                sell: (parameters) => dexActions.sell(client, parameters),
                sellSync: (parameters) => dexActions.sellSync(client, parameters),
                withdraw: (parameters) => dexActions.withdraw(client, parameters),
                withdrawSync: (parameters) => dexActions.withdrawSync(client, parameters),
                watchFlipOrderPlaced: (parameters) => dexActions.watchFlipOrderPlaced(client, parameters),
                watchOrderCancelled: (parameters) => dexActions.watchOrderCancelled(client, parameters),
                watchOrderFilled: (parameters) => dexActions.watchOrderFilled(client, parameters),
                watchOrderPlaced: (parameters) => dexActions.watchOrderPlaced(client, parameters),
            },
            faucet: {
                fund: (parameters) => faucetActions.fund(client, parameters),
            },
            fee: {
                getUserToken: (parameters) => feeActions.getUserToken(client, parameters),
                setUserToken: (parameters) => feeActions.setUserToken(client, parameters),
                setUserTokenSync: (parameters) => feeActions.setUserTokenSync(client, parameters),
                watchSetUserToken: (parameters) => feeActions.watchSetUserToken(client, parameters),
            },
            policy: {
                create: (parameters) => policyActions.create(client, parameters),
                createSync: (parameters) => policyActions.createSync(client, parameters),
                setAdmin: (parameters) => policyActions.setAdmin(client, parameters),
                setAdminSync: (parameters) => policyActions.setAdminSync(client, parameters),
                modifyWhitelist: (parameters) => policyActions.modifyWhitelist(client, parameters),
                modifyWhitelistSync: (parameters) => policyActions.modifyWhitelistSync(client, parameters),
                modifyBlacklist: (parameters) => policyActions.modifyBlacklist(client, parameters),
                modifyBlacklistSync: (parameters) => policyActions.modifyBlacklistSync(client, parameters),
                getData: (parameters) => policyActions.getData(client, parameters),
                isAuthorized: (parameters) => policyActions.isAuthorized(client, parameters),
                watchCreate: (parameters) => policyActions.watchCreate(client, parameters),
                watchAdminUpdated: (parameters) => policyActions.watchAdminUpdated(client, parameters),
                watchWhitelistUpdated: (parameters) => policyActions.watchWhitelistUpdated(client, parameters),
                watchBlacklistUpdated: (parameters) => policyActions.watchBlacklistUpdated(client, parameters),
            },
            reward: {
                claim: (parameters) => rewardActions.claim(client, parameters),
                claimSync: (parameters) => rewardActions.claimSync(client, parameters),
                distribute: (parameters) => rewardActions.distribute(client, parameters),
                distributeSync: (parameters) => rewardActions.distributeSync(client, parameters),
                getUserRewardInfo: (parameters) => rewardActions.getUserRewardInfo(client, parameters),
                setRecipient: (parameters) => rewardActions.setRecipient(client, parameters),
                setRecipientSync: (parameters) => rewardActions.setRecipientSync(client, parameters),
                watchRewardDistributed: (parameters) => rewardActions.watchRewardDistributed(client, parameters),
                watchRewardRecipientSet: (parameters) => rewardActions.watchRewardRecipientSet(client, parameters),
            },
            token: {
                approve: (parameters) => tokenActions.approve(client, parameters),
                approveSync: (parameters) => tokenActions.approveSync(client, parameters),
                burnBlocked: (parameters) => tokenActions.burnBlocked(client, parameters),
                burnBlockedSync: (parameters) => tokenActions.burnBlockedSync(client, parameters),
                burn: (parameters) => tokenActions.burn(client, parameters),
                burnSync: (parameters) => tokenActions.burnSync(client, parameters),
                changeTransferPolicy: (parameters) => tokenActions.changeTransferPolicy(client, parameters),
                changeTransferPolicySync: (parameters) => tokenActions.changeTransferPolicySync(client, parameters),
                create: (parameters) => tokenActions.create(client, parameters),
                createSync: (parameters) => tokenActions.createSync(client, parameters),
                getAllowance: (parameters) => tokenActions.getAllowance(client, parameters),
                getBalance: (parameters) => tokenActions.getBalance(client, parameters),
                getMetadata: (parameters) => tokenActions.getMetadata(client, parameters),
                getRoleAdmin: (parameters) => tokenActions.getRoleAdmin(client, parameters),
                hasRole: (parameters) => tokenActions.hasRole(client, parameters),
                grantRoles: (parameters) => tokenActions.grantRoles(client, parameters),
                grantRolesSync: (parameters) => tokenActions.grantRolesSync(client, parameters),
                mint: (parameters) => tokenActions.mint(client, parameters),
                mintSync: (parameters) => tokenActions.mintSync(client, parameters),
                pause: (parameters) => tokenActions.pause(client, parameters),
                pauseSync: (parameters) => tokenActions.pauseSync(client, parameters),
                renounceRoles: (parameters) => tokenActions.renounceRoles(client, parameters),
                renounceRolesSync: (parameters) => tokenActions.renounceRolesSync(client, parameters),
                revokeRoles: (parameters) => tokenActions.revokeRoles(client, parameters),
                revokeRolesSync: (parameters) => tokenActions.revokeRolesSync(client, parameters),
                setSupplyCap: (parameters) => tokenActions.setSupplyCap(client, parameters),
                setSupplyCapSync: (parameters) => tokenActions.setSupplyCapSync(client, parameters),
                setRoleAdmin: (parameters) => tokenActions.setRoleAdmin(client, parameters),
                setRoleAdminSync: (parameters) => tokenActions.setRoleAdminSync(client, parameters),
                transfer: (parameters) => tokenActions.transfer(client, parameters),
                transferSync: (parameters) => tokenActions.transferSync(client, parameters),
                unpause: (parameters) => tokenActions.unpause(client, parameters),
                unpauseSync: (parameters) => tokenActions.unpauseSync(client, parameters),
                watchApprove: (parameters) => tokenActions.watchApprove(client, parameters),
                watchBurn: (parameters) => tokenActions.watchBurn(client, parameters),
                watchCreate: (parameters) => tokenActions.watchCreate(client, parameters),
                watchMint: (parameters) => tokenActions.watchMint(client, parameters),
                watchAdminRole: (parameters) => tokenActions.watchAdminRole(client, parameters),
                watchRole: (parameters) => tokenActions.watchRole(client, parameters),
                watchTransfer: (parameters) => tokenActions.watchTransfer(client, parameters),
            },
        };
    };
}
//# sourceMappingURL=Decorator.js.map