@sentio/sdk 2.3.5 → 2.4.0-rc.1

package/lib/eth/tests/types/internal/tokenexchange-processor.js

@@ -0,0 +1,667 @@
+import { addContractByABI, getContractByABI, addProcessor, getProcessor, getProvider, transformEtherError, BaseProcessor, BaseProcessorTemplate, BoundContractView, ContractView, DummyProvider, toBlockTag, } from "@sentio/sdk/eth";
+import { TokenExchange__factory } from "./index.js";
+const templateContract = TokenExchange__factory.connect("0x0", DummyProvider);
+export class TokenExchangeContractView extends ContractView {
+    constructor(contract) {
+        super(contract);
+    }
+    async A(overrides) {
+        try {
+            return await this.contract.getFunction("A()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async get_virtual_price(overrides) {
+        try {
+            return await this.contract.getFunction("get_virtual_price()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async calc_token_amount(amounts, deposit, overrides) {
+        try {
+            return await this.contract.getFunction("calc_token_amount(uint256[],bool)")(amounts, deposit, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async get_dy(i, j, dx, overrides) {
+        try {
+            return await this.contract.getFunction("get_dy(int128,int128,uint256)")(i, j, dx, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async get_dy_underlying(i, j, dx, overrides) {
+        try {
+            return await this.contract.getFunction("get_dy_underlying(int128,int128,uint256)")(i, j, dx, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async calc_withdraw_one_coin(_token_amount, i, overrides) {
+        try {
+            return await this.contract.getFunction("calc_withdraw_one_coin(uint256,int128)")(_token_amount, i, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async admin_balances(i, overrides) {
+        try {
+            return await this.contract.getFunction("admin_balances(uint256)")(i, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async coins(arg0, overrides) {
+        try {
+            return await this.contract.getFunction("coins(uint256)")(arg0, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async balances(arg0, overrides) {
+        try {
+            return await this.contract.getFunction("balances(uint256)")(arg0, overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async fee(overrides) {
+        try {
+            return await this.contract.getFunction("fee()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async admin_fee(overrides) {
+        try {
+            return await this.contract.getFunction("admin_fee()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async owner(overrides) {
+        try {
+            return await this.contract.getFunction("owner()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async initial_A(overrides) {
+        try {
+            return await this.contract.getFunction("initial_A()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async future_A(overrides) {
+        try {
+            return await this.contract.getFunction("future_A()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async initial_A_time(overrides) {
+        try {
+            return await this.contract.getFunction("initial_A_time()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async future_A_time(overrides) {
+        try {
+            return await this.contract.getFunction("future_A_time()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async admin_actions_deadline(overrides) {
+        try {
+            return await this.contract.getFunction("admin_actions_deadline()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async transfer_ownership_deadline(overrides) {
+        try {
+            return await this.contract.getFunction("transfer_ownership_deadline()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async future_fee(overrides) {
+        try {
+            return await this.contract.getFunction("future_fee()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async future_admin_fee(overrides) {
+        try {
+            return await this.contract.getFunction("future_admin_fee()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+    async future_owner(overrides) {
+        try {
+            return await this.contract.getFunction("future_owner()")(overrides || {});
+        }
+        catch (e) {
+            throw transformEtherError(e, undefined);
+        }
+    }
+}
+export class TokenExchangeBoundContractView extends BoundContractView {
+    async A(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.A(overrides || {});
+    }
+    async get_virtual_price(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.get_virtual_price(overrides || {});
+    }
+    async calc_token_amount(amounts, deposit, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.calc_token_amount(amounts, deposit, overrides || {});
+    }
+    async get_dy(i, j, dx, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.get_dy(i, j, dx, overrides || {});
+    }
+    async get_dy_underlying(i, j, dx, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.get_dy_underlying(i, j, dx, overrides || {});
+    }
+    async calc_withdraw_one_coin(_token_amount, i, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.calc_withdraw_one_coin(_token_amount, i, overrides || {});
+    }
+    async admin_balances(i, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.admin_balances(i, overrides || {});
+    }
+    async coins(arg0, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.coins(arg0, overrides || {});
+    }
+    async balances(arg0, overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.balances(arg0, overrides || {});
+    }
+    async fee(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.fee(overrides || {});
+    }
+    async admin_fee(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.admin_fee(overrides || {});
+    }
+    async owner(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.owner(overrides || {});
+    }
+    async initial_A(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.initial_A(overrides || {});
+    }
+    async future_A(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.future_A(overrides || {});
+    }
+    async initial_A_time(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.initial_A_time(overrides || {});
+    }
+    async future_A_time(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.future_A_time(overrides || {});
+    }
+    async admin_actions_deadline(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.admin_actions_deadline(overrides || {});
+    }
+    async transfer_ownership_deadline(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.transfer_ownership_deadline(overrides || {});
+    }
+    async future_fee(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.future_fee(overrides || {});
+    }
+    async future_admin_fee(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.future_admin_fee(overrides || {});
+    }
+    async future_owner(overrides) {
+        if (!overrides && this.context) {
+            overrides = {
+                blockTag: toBlockTag(this.context.blockNumber),
+            };
+        }
+        return await this.view.future_owner(overrides || {});
+    }
+}
+export class TokenExchangeProcessor extends BaseProcessor {
+    onEventTokenExchange(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["TokenExchange(address,int128,uint256,int128,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventAddLiquidity(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["AddLiquidity(address,uint256[],uint256[],uint256,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidity(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidity(address,uint256[],uint256[],uint256)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidityOne(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidityOne(address,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidityImbalance(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidityImbalance(address,uint256[],uint256[],uint256,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventCommitNewAdmin(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["CommitNewAdmin(uint256,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventNewAdmin(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["NewAdmin(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventCommitNewFee(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["CommitNewFee(uint256,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventNewFee(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["NewFee(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRampA(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RampA(uint256,uint256,uint256,uint256)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventStopRampA(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["StopRampA(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onCallA(handler, fetchConfig) {
+        return super.onTrace("0xf446c1d0", handler, fetchConfig);
+    }
+    onCallGet_virtual_price(handler, fetchConfig) {
+        return super.onTrace("0xbb7b8b80", handler, fetchConfig);
+    }
+    onCallCalc_token_amount(handler, fetchConfig) {
+        return super.onTrace("0x3883e119", handler, fetchConfig);
+    }
+    onCallAdd_liquidity(handler, fetchConfig) {
+        return super.onTrace("0x4515cef3", handler, fetchConfig);
+    }
+    onCallGet_dy(handler, fetchConfig) {
+        return super.onTrace("0x5e0d443f", handler, fetchConfig);
+    }
+    onCallGet_dy_underlying(handler, fetchConfig) {
+        return super.onTrace("0x07211ef7", handler, fetchConfig);
+    }
+    onCallExchange(handler, fetchConfig) {
+        return super.onTrace("0x3df02124", handler, fetchConfig);
+    }
+    onCallRemove_liquidity(handler, fetchConfig) {
+        return super.onTrace("0xecb586a5", handler, fetchConfig);
+    }
+    onCallRemove_liquidity_imbalance(handler, fetchConfig) {
+        return super.onTrace("0x9fdaea0c", handler, fetchConfig);
+    }
+    onCallCalc_withdraw_one_coin(handler, fetchConfig) {
+        return super.onTrace("0xcc2b27d7", handler, fetchConfig);
+    }
+    onCallRemove_liquidity_one_coin(handler, fetchConfig) {
+        return super.onTrace("0x1a4d01d2", handler, fetchConfig);
+    }
+    onCallRamp_A(handler, fetchConfig) {
+        return super.onTrace("0x3c157e64", handler, fetchConfig);
+    }
+    onCallStop_ramp_A(handler, fetchConfig) {
+        return super.onTrace("0x551a6588", handler, fetchConfig);
+    }
+    onCallCommit_new_fee(handler, fetchConfig) {
+        return super.onTrace("0x5b5a1467", handler, fetchConfig);
+    }
+    onCallApply_new_fee(handler, fetchConfig) {
+        return super.onTrace("0x4f12fe97", handler, fetchConfig);
+    }
+    onCallRevert_new_parameters(handler, fetchConfig) {
+        return super.onTrace("0x226840fb", handler, fetchConfig);
+    }
+    onCallCommit_transfer_ownership(handler, fetchConfig) {
+        return super.onTrace("0x6b441a40", handler, fetchConfig);
+    }
+    onCallApply_transfer_ownership(handler, fetchConfig) {
+        return super.onTrace("0x6a1c05ae", handler, fetchConfig);
+    }
+    onCallRevert_transfer_ownership(handler, fetchConfig) {
+        return super.onTrace("0x86fbf193", handler, fetchConfig);
+    }
+    onCallAdmin_balances(handler, fetchConfig) {
+        return super.onTrace("0xe2e7d264", handler, fetchConfig);
+    }
+    onCallWithdraw_admin_fees(handler, fetchConfig) {
+        return super.onTrace("0x30c54085", handler, fetchConfig);
+    }
+    onCallDonate_admin_fees(handler, fetchConfig) {
+        return super.onTrace("0x524c3901", handler, fetchConfig);
+    }
+    onCallKill_me(handler, fetchConfig) {
+        return super.onTrace("0xe3698853", handler, fetchConfig);
+    }
+    onCallUnkill_me(handler, fetchConfig) {
+        return super.onTrace("0x3046f972", handler, fetchConfig);
+    }
+    onCallCoins(handler, fetchConfig) {
+        return super.onTrace("0xc6610657", handler, fetchConfig);
+    }
+    onCallBalances(handler, fetchConfig) {
+        return super.onTrace("0x4903b0d1", handler, fetchConfig);
+    }
+    onCallFee(handler, fetchConfig) {
+        return super.onTrace("0xddca3f43", handler, fetchConfig);
+    }
+    onCallAdmin_fee(handler, fetchConfig) {
+        return super.onTrace("0xfee3f7f9", handler, fetchConfig);
+    }
+    onCallOwner(handler, fetchConfig) {
+        return super.onTrace("0x8da5cb5b", handler, fetchConfig);
+    }
+    onCallInitial_A(handler, fetchConfig) {
+        return super.onTrace("0x5409491a", handler, fetchConfig);
+    }
+    onCallFuture_A(handler, fetchConfig) {
+        return super.onTrace("0xb4b577ad", handler, fetchConfig);
+    }
+    onCallInitial_A_time(handler, fetchConfig) {
+        return super.onTrace("0x2081066c", handler, fetchConfig);
+    }
+    onCallFuture_A_time(handler, fetchConfig) {
+        return super.onTrace("0x14052288", handler, fetchConfig);
+    }
+    onCallAdmin_actions_deadline(handler, fetchConfig) {
+        return super.onTrace("0x405e28f8", handler, fetchConfig);
+    }
+    onCallTransfer_ownership_deadline(handler, fetchConfig) {
+        return super.onTrace("0xe0a0b586", handler, fetchConfig);
+    }
+    onCallFuture_fee(handler, fetchConfig) {
+        return super.onTrace("0x58680d0b", handler, fetchConfig);
+    }
+    onCallFuture_admin_fee(handler, fetchConfig) {
+        return super.onTrace("0xe3824462", handler, fetchConfig);
+    }
+    onCallFuture_owner(handler, fetchConfig) {
+        return super.onTrace("0x1ec0cdc1", handler, fetchConfig);
+    }
+    static filters = {
+        TokenExchange(buyer, sold_id, tokens_sold, bought_id, tokens_bought) {
+            return templateContract.filters["TokenExchange(address,int128,uint256,int128,uint256)"](buyer, sold_id, tokens_sold, bought_id, tokens_bought);
+        },
+        AddLiquidity(provider, token_amounts, fees, invariant, token_supply) {
+            return templateContract.filters["AddLiquidity(address,uint256[],uint256[],uint256,uint256)"](provider, token_amounts, fees, invariant, token_supply);
+        },
+        RemoveLiquidity(provider, token_amounts, fees, token_supply) {
+            return templateContract.filters["RemoveLiquidity(address,uint256[],uint256[],uint256)"](provider, token_amounts, fees, token_supply);
+        },
+        RemoveLiquidityOne(provider, token_amount, coin_amount) {
+            return templateContract.filters["RemoveLiquidityOne(address,uint256,uint256)"](provider, token_amount, coin_amount);
+        },
+        RemoveLiquidityImbalance(provider, token_amounts, fees, invariant, token_supply) {
+            return templateContract.filters["RemoveLiquidityImbalance(address,uint256[],uint256[],uint256,uint256)"](provider, token_amounts, fees, invariant, token_supply);
+        },
+        CommitNewAdmin(deadline, admin) {
+            return templateContract.filters["CommitNewAdmin(uint256,address)"](deadline, admin);
+        },
+        NewAdmin(admin) {
+            return templateContract.filters["NewAdmin(address)"](admin);
+        },
+        CommitNewFee(deadline, fee, admin_fee) {
+            return templateContract.filters["CommitNewFee(uint256,uint256,uint256)"](deadline, fee, admin_fee);
+        },
+        NewFee(fee, admin_fee) {
+            return templateContract.filters["NewFee(uint256,uint256)"](fee, admin_fee);
+        },
+        RampA(old_A, new_A, initial_time, future_time) {
+            return templateContract.filters["RampA(uint256,uint256,uint256,uint256)"](old_A, new_A, initial_time, future_time);
+        },
+        StopRampA(A, t) {
+            return templateContract.filters["StopRampA(uint256,uint256)"](A, t);
+        },
+    };
+    CreateBoundContractView() {
+        const view = getTokenExchangeContract(this.config.address, this.config.network);
+        return new TokenExchangeBoundContractView(this.config.address, view);
+    }
+    static bind(options) {
+        if (!options.name) {
+            options.name = "TokenExchange";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new TokenExchangeProcessor(options);
+            addProcessor(options, processor);
+        }
+        return processor;
+    }
+}
+export class TokenExchangeProcessorTemplate extends BaseProcessorTemplate {
+    bindInternal(options) {
+        if (!options.name) {
+            options.name = "TokenExchange";
+        }
+        let processor = getProcessor(options);
+        if (!processor) {
+            processor = new TokenExchangeProcessor(options);
+            addProcessor(options, processor);
+        }
+        return processor;
+    }
+    onEventTokenExchange(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["TokenExchange(address,int128,uint256,int128,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventAddLiquidity(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["AddLiquidity(address,uint256[],uint256[],uint256,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidity(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidity(address,uint256[],uint256[],uint256)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidityOne(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidityOne(address,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRemoveLiquidityImbalance(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RemoveLiquidityImbalance(address,uint256[],uint256[],uint256,uint256)"](null, null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventCommitNewAdmin(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["CommitNewAdmin(uint256,address)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventNewAdmin(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["NewAdmin(address)"](null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventCommitNewFee(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["CommitNewFee(uint256,uint256,uint256)"](null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventNewFee(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["NewFee(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventRampA(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["RampA(uint256,uint256,uint256,uint256)"](null, null, null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+    onEventStopRampA(handler, filter, fetchConfig) {
+        if (!filter) {
+            filter = templateContract.filters["StopRampA(uint256,uint256)"](null, null);
+        }
+        return super.onEvent(handler, filter, fetchConfig);
+    }
+}
+export function getTokenExchangeContract(address, network = 1) {
+    let contract = getContractByABI("TokenExchange", address, network);
+    if (!contract) {
+        const rawContract = TokenExchange__factory.connect(address, getProvider(network));
+        contract = new TokenExchangeContractView(rawContract);
+        addContractByABI("TokenExchange", address, network, contract);
+    }
+    return contract;
+}
+//# sourceMappingURL=tokenexchange-processor.js.map