viem/_esm/tempo/Decorator.js

TypeScript Interface for Ethereum

import * as accessKeyActions from './actions/accessKey.js';
import * as ammActions from './actions/amm.js';
import * as channelActions from './actions/channel.js';
import * as dexActions from './actions/dex.js';
import * as faucetActions from './actions/faucet.js';
import * as feeActions from './actions/fee.js';
import * as nonceActions from './actions/nonce.js';
import * as policyActions from './actions/policy.js';
import * as rewardActions from './actions/reward.js';
import * as simulateActions from './actions/simulate.js';
import * as tokenActions from './actions/token.js';
import * as validatorActions from './actions/validator.js';
import * as virtualAddressActions from './actions/virtualAddress.js';
import * as zoneActions from './actions/zone.js';
export function decorator() {
    return (client) => {
        return {
            accessKey: {
                authorize: (parameters) => accessKeyActions.authorize(client, parameters),
                authorizeSync: (parameters) => accessKeyActions.authorizeSync(client, parameters),
                getMetadata: (parameters) => accessKeyActions.getMetadata(client, parameters),
                getRemainingLimit: (parameters) => accessKeyActions.getRemainingLimit(client, parameters),
                revoke: (parameters) => accessKeyActions.revoke(client, parameters),
                revokeSync: (parameters) => accessKeyActions.revokeSync(client, parameters),
                updateLimit: (parameters) => accessKeyActions.updateLimit(client, parameters),
                updateLimitSync: (parameters) => accessKeyActions.updateLimitSync(client, parameters),
            },
            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),
            },
            channel: {
                close: (parameters) => channelActions.close(client, parameters),
                closeSync: (parameters) => channelActions.closeSync(client, parameters),
                getStates: (parameters) => channelActions.getStates(client, parameters),
                open: (parameters) => channelActions.open(client, parameters),
                openSync: (parameters) => channelActions.openSync(client, parameters),
                requestClose: (parameters) => channelActions.requestClose(client, parameters),
                requestCloseSync: (parameters) => channelActions.requestCloseSync(client, parameters),
                settle: (parameters) => channelActions.settle(client, parameters),
                settleSync: (parameters) => channelActions.settleSync(client, parameters),
                signVoucher: (parameters) => channelActions.signVoucher(client, parameters),
                topUp: (parameters) => channelActions.topUp(client, parameters),
                topUpSync: (parameters) => channelActions.topUpSync(client, parameters),
                withdraw: (parameters) => channelActions.withdraw(client, parameters),
                withdrawSync: (parameters) => channelActions.withdrawSync(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),
                fundSync: (parameters) => faucetActions.fundSync(client, parameters),
            },
            nonce: {
                getNonce: (parameters) => nonceActions.getNonce(client, parameters),
                watchNonceIncremented: (parameters) => nonceActions.watchNonceIncremented(client, parameters),
            },
            fee: {
                validateToken: (parameters) => feeActions.validateToken(client, parameters),
                // @ts-expect-error
                getUserToken: (parameters) => 
                // @ts-expect-error
                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),
            },
            simulate: {
                simulateBlocks: (parameters) => simulateActions.simulateBlocks(client, parameters),
                simulateCalls: (parameters) => simulateActions.simulateCalls(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),
            },
            validator: {
                add: (parameters) => validatorActions.add(client, parameters),
                addSync: (parameters) => validatorActions.addSync(client, parameters),
                changeOwner: (parameters) => validatorActions.changeOwner(client, parameters),
                changeOwnerSync: (parameters) => validatorActions.changeOwnerSync(client, parameters),
                changeStatus: (parameters) => validatorActions.changeStatus(client, parameters),
                changeStatusSync: (parameters) => validatorActions.changeStatusSync(client, parameters),
                get: (parameters) => validatorActions.get(client, parameters),
                getByIndex: (parameters) => validatorActions.getByIndex(client, parameters),
                getCount: (parameters) => validatorActions.getCount(client, parameters),
                getNextFullDkgCeremony: (parameters) => validatorActions.getNextFullDkgCeremony(client, parameters),
                getOwner: (parameters) => validatorActions.getOwner(client, parameters),
                list: (parameters) => validatorActions.list(client, parameters),
                setNextFullDkgCeremony: (parameters) => validatorActions.setNextFullDkgCeremony(client, parameters),
                setNextFullDkgCeremonySync: (parameters) => validatorActions.setNextFullDkgCeremonySync(client, parameters),
                update: (parameters) => validatorActions.update(client, parameters),
                updateSync: (parameters) => validatorActions.updateSync(client, parameters),
            },
            virtualAddress: {
                getMasterAddress: (parameters) => virtualAddressActions.getMasterAddress(client, parameters),
                registerMaster: (parameters) => virtualAddressActions.registerMaster(client, parameters),
                registerMasterSync: (parameters) => virtualAddressActions.registerMasterSync(client, parameters),
                resolve: (parameters) => virtualAddressActions.resolve(client, parameters),
            },
            zone: {
                deposit: (parameters) => zoneActions.deposit(client, parameters),
                depositSync: (parameters) => zoneActions.depositSync(client, parameters),
                encryptedDeposit: (parameters) => zoneActions.encryptedDeposit(client, parameters),
                encryptedDepositSync: (parameters) => zoneActions.encryptedDepositSync(client, parameters),
                getAuthorizationTokenInfo: () => zoneActions.getAuthorizationTokenInfo(client),
                getDepositStatus: (parameters) => zoneActions.getDepositStatus(client, parameters),
                getWithdrawalFee: (parameters) => zoneActions.getWithdrawalFee(client, parameters),
                getZoneInfo: () => zoneActions.getZoneInfo(client),
                requestWithdrawal: (parameters) => zoneActions.requestWithdrawal(client, parameters),
                requestWithdrawalSync: (parameters) => zoneActions.requestWithdrawalSync(client, parameters),
                requestVerifiableWithdrawal: (parameters) => zoneActions.requestVerifiableWithdrawal(client, parameters),
                requestVerifiableWithdrawalSync: (parameters) => zoneActions.requestVerifiableWithdrawalSync(client, parameters),
                signAuthorizationToken: (parameters) => zoneActions.signAuthorizationToken(client, parameters),
            },
        };
    };
}
//# sourceMappingURL=Decorator.js.map