@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/hook/EvmHookReader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvmHookReader.test.d.ts","sourceRoot":"","sources":["../../src/hook/EvmHookReader.test.ts"],"names":[],"mappings":""}

package/dist/hook/EvmHookReader.test.js

@@ -0,0 +1,647 @@
+import { expect } from 'chai';
+import { ethers } from 'ethers';
+import { randomBytes } from 'ethers/lib/utils.js';
+import sinon from 'sinon';
+import { CCIPHook__factory, DefaultHook__factory, DelayedFlowRouterHookIsm__factory, DomainRoutingHook__factory, IPostDispatchHook__factory, InterchainGasPaymaster__factory, MerkleTreeHook__factory, NetFlowRateLimitedHookIsm__factory, OPStackHook__factory, PackageVersioned__factory, PausableHook__factory, ProtocolFee__factory, RateLimitedHook__factory, StorageGasOracle__factory, } from '@recoillink/core';
+import { addressToBytes32 } from '@recoillink/utils';
+import { TestChainName, test1 } from '../consts/testChains.js';
+import { MultiProvider } from '../providers/MultiProvider.js';
+import { missingSelectorError, networkError, wrappedError, } from '../test/errors.js';
+import { contractDouble } from '../test/contractDouble.js';
+import { randomAddress } from '../test/testUtils.js';
+import { EvmHookReader } from './EvmHookReader.js';
+import { HookType, IgpVersion, OFFCHAIN_QUOTED_IGP_VERSION, OnchainHookType, } from './types.js';
+// Message HyperlaneJsonRpcProvider emits for an empty eth_call result, which
+// isEmptyProviderResponse (utils/contract.ts) string-matches to detect a
+// missing-selector revert. Kept in one place so the coupling can't drift.
+const EMPTY_PROVIDER_RESPONSE_MESSAGE = 'Invalid response from provider';
+describe('EvmHookReader', () => {
+    let evmHookReader;
+    let multiProvider;
+    let sandbox;
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        multiProvider = MultiProvider.createTestMultiProvider();
+        evmHookReader = new EvmHookReader(multiProvider, TestChainName.test1);
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    // deriveIgpConfig reads PACKAGE_VERSION off PackageVersioned to decide whether
+    // an IGP is legacy (pre-quoteSigners). A version string stubs the read; an
+    // Error stubs the revert (missing selector => legacy, else propagates).
+    const stubIgpPackageVersion = (version) => {
+        const packageVersion = sandbox.stub();
+        if (version instanceof Error) {
+            packageVersion.rejects(version);
+        }
+        else {
+            packageVersion.resolves(version);
+        }
+        sandbox.stub(PackageVersioned__factory, 'connect').returns({
+            PACKAGE_VERSION: packageVersion,
+        });
+    };
+    it('should derive merkle tree config correctly', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.MERKLE_TREE),
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(MerkleTreeHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const expectedConfig = {
+            address: mockAddress,
+            type: HookType.MERKLE_TREE,
+        };
+        // top-level method infers hook type
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+        // should get same result if we call the specific method for the hook type
+        const config = await evmHookReader.deriveMerkleTreeConfig(mockAddress);
+        expect(config).to.deep.equal(hookConfig);
+    });
+    it('should derive protocol fee hook correctly', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const mockBeneficiary = randomAddress();
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.PROTOCOL_FEE),
+            owner: sandbox.stub().resolves(mockOwner),
+            MAX_PROTOCOL_FEE: sandbox.stub().resolves(ethers.BigNumber.from('1000')),
+            protocolFee: sandbox.stub().resolves(ethers.BigNumber.from('10')),
+            beneficiary: sandbox.stub().resolves(mockBeneficiary),
+        };
+        sandbox
+            .stub(ProtocolFee__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const expectedConfig = {
+            owner: mockOwner,
+            address: mockAddress,
+            type: HookType.PROTOCOL_FEE,
+            maxProtocolFee: '1000',
+            protocolFee: '10',
+            beneficiary: mockBeneficiary,
+        };
+        // top-level method infers hook type
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+        // should get same result if we call the specific method for the hook type
+        const config = await evmHookReader.deriveProtocolFeeConfig(mockAddress);
+        expect(config).to.deep.equal(hookConfig);
+    });
+    it('should derive pausable config correctly', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const mockPaused = randomBytes(1)[0] % 2 === 0;
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.PAUSABLE),
+            owner: sandbox.stub().resolves(mockOwner),
+            paused: sandbox.stub().resolves(mockPaused),
+        };
+        sandbox
+            .stub(PausableHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const expectedConfig = {
+            owner: mockOwner,
+            paused: mockPaused,
+            address: mockAddress,
+            type: HookType.PAUSABLE,
+        };
+        // top-level method infers hook type
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+        // should get same result if we call the specific method for the hook type
+        const config = await evmHookReader.derivePausableConfig(mockAddress);
+        expect(config).to.deep.equal(hookConfig);
+    });
+    it('should derive mailbox default hook config correctly', async () => {
+        const mockAddress = randomAddress();
+        const mockMailbox = randomAddress();
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.MAILBOX_DEFAULT_HOOK),
+            mailbox: sandbox.stub().resolves(mockMailbox),
+        };
+        sandbox
+            .stub(DefaultHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const expectedConfig = {
+            address: mockAddress,
+            type: HookType.MAILBOX_DEFAULT,
+        };
+        // top-level method infers hook type
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+        // should get same result if we call the specific method for the hook type
+        const config = await evmHookReader.deriveMailboxDefaultHookConfig(mockAddress);
+        expect(config).to.deep.equal(hookConfig);
+    });
+    it('should derive op stack config correctly', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const l1Messenger = randomAddress();
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.ID_AUTH_ISM),
+            owner: sandbox.stub().resolves(mockOwner),
+            l1Messenger: sandbox.stub().resolves(l1Messenger),
+            destinationDomain: sandbox.stub().resolves(test1.domainId),
+        };
+        sandbox
+            .stub(OPStackHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox.stub(CCIPHook__factory, 'connect').returns({
+            ccipDestination: sandbox.stub().rejects(missingSelectorError()),
+        });
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const expectedConfig = {
+            owner: mockOwner,
+            address: mockAddress,
+            type: HookType.OP_STACK,
+            nativeBridge: l1Messenger,
+            destinationChain: TestChainName.test1,
+        };
+        // top-level method infers hook type
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+        // should get same result if we call the specific method for the hook type
+        const config = await evmHookReader.deriveOpStackConfig(mockAddress);
+        expect(config).to.deep.equal(hookConfig);
+    });
+    it('should derive CCIPHook configuration correctly', async () => {
+        const ccipHookAddress = randomAddress();
+        const destinationDomain = test1.domainId;
+        const ism = randomAddress();
+        // Mock the CCIPHook contract
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.ID_AUTH_ISM),
+            destinationDomain: sandbox.stub().resolves(destinationDomain),
+            ism: sandbox.stub().resolves(ism),
+        };
+        sandbox
+            .stub(CCIPHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        const config = await evmHookReader.deriveCcipConfig(ccipHookAddress);
+        const expectedConfig = {
+            address: ccipHookAddress,
+            type: HookType.CCIP,
+            destinationChain: TestChainName.test1,
+        };
+        expect(config).to.deep.equal(expectedConfig);
+    });
+    it('should not treat transient ID_AUTH hook probe failures as missing methods', async () => {
+        const mockAddress = randomAddress();
+        const transientError = networkError();
+        sandbox.stub(CCIPHook__factory, 'connect').returns({
+            ccipDestination: sandbox.stub().rejects(transientError),
+        });
+        let thrown;
+        try {
+            await evmHookReader.deriveIdAuthIsmConfig(mockAddress);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        expect(thrown).to.equal(transientError);
+    });
+    it('should propagate transient quoteSigners failures on a v2 IGP', async () => {
+        const mockAddress = randomAddress();
+        const transientError = networkError();
+        stubIgpPackageVersion(OFFCHAIN_QUOTED_IGP_VERSION);
+        sandbox.stub(InterchainGasPaymaster__factory, 'connect').returns({
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(randomAddress()),
+            beneficiary: sandbox.stub().resolves(randomAddress()),
+            quoteSigners: sandbox.stub().rejects(transientError),
+        });
+        let thrown;
+        try {
+            await evmHookReader.deriveIgpConfig(mockAddress);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        expect(thrown).to.equal(transientError);
+    });
+    it('should propagate empty provider responses from quoteSigners on a v2 IGP', async () => {
+        const mockAddress = randomAddress();
+        const emptyProviderResponse = new Error(EMPTY_PROVIDER_RESPONSE_MESSAGE);
+        stubIgpPackageVersion(OFFCHAIN_QUOTED_IGP_VERSION);
+        sandbox.stub(InterchainGasPaymaster__factory, 'connect').returns({
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(randomAddress()),
+            beneficiary: sandbox.stub().resolves(randomAddress()),
+            quoteSigners: sandbox.stub().rejects(emptyProviderResponse),
+        });
+        let thrown;
+        try {
+            await evmHookReader.deriveIgpConfig(mockAddress);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        expect(thrown).to.equal(emptyProviderResponse);
+    });
+    it('should classify a legacy IGP when PACKAGE_VERSION revert is wrapped by the SmartProvider', async () => {
+        const mockAddress = randomAddress();
+        const owner = randomAddress();
+        const beneficiary = randomAddress();
+        // Real production shape: a legacy IGP's empty-data revert surfaces through
+        // HyperlaneSmartProvider as "All providers failed" whose cause chain is
+        // "Invalid response from provider" (never a CALL_EXCEPTION).
+        stubIgpPackageVersion(wrappedError(new Error(EMPTY_PROVIDER_RESPONSE_MESSAGE)));
+        sandbox.stub(evmHookReader, 'possibleDomainIds').returns([]);
+        sandbox.stub(InterchainGasPaymaster__factory, 'connect').returns({
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(owner),
+            beneficiary: sandbox.stub().resolves(beneficiary),
+            quoteSigners: sandbox
+                .stub()
+                .rejects(new Error('quoteSigners must not be called on a legacy IGP')),
+        });
+        const config = await evmHookReader.deriveIgpConfig(mockAddress);
+        expect(config).to.deep.equal({
+            owner,
+            address: mockAddress,
+            type: HookType.INTERCHAIN_GAS_PAYMASTER,
+            beneficiary,
+            igpVersion: IgpVersion.Legacy,
+            oracleKey: owner,
+            overhead: {},
+            oracleConfig: {},
+        });
+    });
+    it('should still derive IGP config when a domain is unsupported', async () => {
+        const mockAddress = randomAddress();
+        const owner = randomAddress();
+        const beneficiary = randomAddress();
+        const domainId = test1.domainId;
+        stubIgpPackageVersion(missingSelectorError());
+        sandbox.stub(evmHookReader, 'possibleDomainIds').returns([domainId]);
+        sandbox.stub(InterchainGasPaymaster__factory, 'connect').returns({
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(owner),
+            beneficiary: sandbox.stub().resolves(beneficiary),
+            quoteSigners: sandbox
+                .stub()
+                .rejects(new Error('quoteSigners must not be called on a legacy IGP')),
+            getExchangeRateAndGasPrice: sandbox
+                .stub()
+                .rejects(new Error(`Configured IGP doesn't support domain ${domainId}`)),
+        });
+        const config = await evmHookReader.deriveIgpConfig(mockAddress);
+        expect(config).to.deep.equal({
+            owner,
+            address: mockAddress,
+            type: HookType.INTERCHAIN_GAS_PAYMASTER,
+            beneficiary,
+            igpVersion: IgpVersion.Legacy,
+            oracleKey: owner,
+            overhead: {},
+            oracleConfig: {},
+        });
+    });
+    it('should derive a net flow rate limited hook ism (not a plain rate limited hook)', async () => {
+        const mockAddress = randomAddress();
+        const mockWarpRouter = randomAddress();
+        const mockOwner = randomAddress();
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.RATE_LIMITED),
+            warpRouter: sandbox.stub().resolves(mockWarpRouter),
+            thresholdBps: sandbox.stub().resolves(ethers.BigNumber.from(500)),
+            DURATION: sandbox.stub().resolves(ethers.BigNumber.from(86400)),
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(NetFlowRateLimitedHookIsm__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        const expectedConfig = {
+            address: mockAddress,
+            type: HookType.NET_FLOW_RATE_LIMITED,
+            warpRouter: mockWarpRouter,
+            thresholdBps: 500,
+            duration: 86400n,
+            owner: mockOwner,
+        };
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+    });
+    it('should preserve a nested net flow hook ism as a typed config', async () => {
+        const mockAddress = randomAddress();
+        const mockWarpRouter = randomAddress();
+        const mockOwner = randomAddress();
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.RATE_LIMITED),
+            warpRouter: sandbox.stub().resolves(mockWarpRouter),
+            thresholdBps: sandbox.stub().resolves(ethers.BigNumber.from(500)),
+            DURATION: sandbox.stub().resolves(ethers.BigNumber.from(86400)),
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(NetFlowRateLimitedHookIsm__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        const hookConfig = await evmHookReader.deriveHookConfig({
+            type: HookType.AGGREGATION,
+            hooks: [mockAddress],
+        });
+        expect(hookConfig).to.deep.equal({
+            type: HookType.AGGREGATION,
+            hooks: [
+                {
+                    address: mockAddress,
+                    type: HookType.NET_FLOW_RATE_LIMITED,
+                    warpRouter: mockWarpRouter,
+                    thresholdBps: 500,
+                    duration: 86400n,
+                    owner: mockOwner,
+                },
+            ],
+        });
+    });
+    it('should still derive a plain rate limited hook when the hybrid probe misses', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.RATE_LIMITED),
+            thresholdBps: sandbox.stub().rejects(missingSelectorError()),
+            maxCapacity: sandbox.stub().resolves(ethers.BigNumber.from('86400')),
+            DURATION: sandbox.stub().resolves(ethers.BigNumber.from(86400)),
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(NetFlowRateLimitedHookIsm__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(RateLimitedHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        const expectedConfig = {
+            address: mockAddress,
+            type: HookType.RATE_LIMITED,
+            maxCapacity: '86400',
+            duration: 86400n,
+            owner: mockOwner,
+        };
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+    });
+    it('should derive a delayed flow router hook ism (not a plain domain routing hook)', async () => {
+        const mockAddress = randomAddress();
+        const mockWarpRouter = randomAddress();
+        const mockOwner = randomAddress();
+        const mockRemoteRouter = addressToBytes32(randomAddress()).toLowerCase();
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.ROUTING),
+            maxDelay: sandbox.stub().resolves(3600),
+            warpRouter: sandbox.stub().resolves(mockWarpRouter),
+            thresholdBps: sandbox.stub().resolves(ethers.BigNumber.from(10000)),
+            DURATION: sandbox.stub().resolves(ethers.BigNumber.from(86400)),
+            owner: sandbox.stub().resolves(mockOwner),
+            domains: sandbox.stub().resolves([test1.domainId]),
+            routers: sandbox.stub().resolves(mockRemoteRouter),
+        };
+        sandbox
+            .stub(DelayedFlowRouterHookIsm__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        const expectedConfig = {
+            address: mockAddress,
+            type: HookType.DELAYED_FLOW_ROUTER,
+            warpRouter: mockWarpRouter,
+            thresholdBps: 10000,
+            maxDelay: 3600,
+            duration: 86400n,
+            owner: mockOwner,
+            remoteIsms: { [TestChainName.test1]: mockRemoteRouter },
+        };
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal(expectedConfig);
+    });
+    it('should still derive a plain domain routing hook when the hybrid probe misses', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        sandbox.stub(evmHookReader, 'possibleDomainIds').returns([]);
+        const mockContract = {
+            hookType: sandbox.stub().resolves(OnchainHookType.ROUTING),
+            maxDelay: sandbox.stub().rejects(missingSelectorError()),
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(DelayedFlowRouterHookIsm__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(DomainRoutingHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(contractDouble(mockContract));
+        const hookConfig = await evmHookReader.deriveHookConfig(mockAddress);
+        expect(hookConfig).to.deep.equal({
+            address: mockAddress,
+            type: HookType.ROUTING,
+            owner: mockOwner,
+            domains: {},
+        });
+    });
+    it('should not drop routing hook domains on transient read failures', async () => {
+        const mockAddress = randomAddress();
+        const transientError = networkError();
+        sandbox.stub(evmHookReader, 'possibleDomainIds').returns([test1.domainId]);
+        sandbox.stub(DomainRoutingHook__factory, 'connect').returns({
+            hookType: sandbox.stub().resolves(OnchainHookType.ROUTING),
+            owner: sandbox.stub().resolves(randomAddress()),
+            hooks: sandbox.stub().rejects(transientError),
+        });
+        let thrown;
+        try {
+            await evmHookReader.deriveDomainRoutingConfig(mockAddress);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        expect(thrown).to.equal(transientError);
+    });
+    it('should throw if derivation fails', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        // Mocking the connect method + returned what we need from contract object
+        const mockContract = {
+            // No type
+            owner: sandbox.stub().resolves(mockOwner),
+        };
+        sandbox
+            .stub(MerkleTreeHook__factory, 'connect')
+            .returns(mockContract);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockContract);
+        // top-level method infers hook type
+        try {
+            await evmHookReader.deriveHookConfig(mockAddress);
+        }
+        catch (e) {
+            expect(e.toString()).to.contain(`Failed to derive undefined hook (${mockAddress}):`);
+        }
+    });
+    it('should derive IGP config with tokenOracleConfig', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const mockBeneficiary = randomAddress();
+        const mockOracleAddress = randomAddress();
+        const feeToken = randomAddress();
+        stubIgpPackageVersion(missingSelectorError());
+        const mockIgp = {
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(mockOwner),
+            beneficiary: sandbox.stub().resolves(mockBeneficiary),
+            quoteSigners: sandbox
+                .stub()
+                .rejects(new Error('quoteSigners must not be called on a legacy IGP')),
+            getExchangeRateAndGasPrice: sandbox
+                .stub()
+                .callsFake((domainId) => Promise.reject(new Error(`Configured IGP doesn't support domain ${domainId}`))),
+            destinationGasLimit: sandbox.stub().resolves(ethers.BigNumber.from(0)),
+            destinationGasConfigs: sandbox.stub().resolves({
+                gasOracle: mockOracleAddress,
+                gasOverhead: ethers.BigNumber.from(0),
+            }),
+            tokenGasOracles: sandbox.stub(),
+        };
+        // tokenGasOracles returns zero for all domains except when feeToken matches
+        mockIgp.tokenGasOracles.resolves(ethers.constants.AddressZero);
+        // No configured domains for native oracle
+        mockIgp.getExchangeRateAndGasPrice.callsFake((domainId) => Promise.reject(new Error(`Configured IGP doesn't support domain ${domainId}`)));
+        sandbox
+            .stub(InterchainGasPaymaster__factory, 'connect')
+            .returns(mockIgp);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockIgp);
+        const mockOracle = {
+            owner: sandbox.stub().resolves(mockOwner),
+            remoteGasData: sandbox.stub().resolves({
+                tokenExchangeRate: ethers.BigNumber.from('15000000000'),
+                gasPrice: ethers.BigNumber.from('500000000'),
+            }),
+        };
+        sandbox
+            .stub(StorageGasOracle__factory, 'connect')
+            .returns(mockOracle);
+        // No fee tokens provided - should not have tokenOracleConfig
+        const configNoTokens = await evmHookReader.deriveIgpConfig(mockAddress);
+        expect(configNoTokens.tokenOracleConfig).to.be.undefined;
+        // With fee tokens but all return zero address - should be undefined
+        const configZeroOracle = await evmHookReader.deriveIgpConfig(mockAddress, [
+            feeToken,
+        ]);
+        expect(configZeroOracle.tokenOracleConfig).to.be.undefined;
+    });
+    it('should populate tokenOracleConfig when tokenGasOracles returns non-zero oracle', async () => {
+        const mockAddress = randomAddress();
+        const mockOwner = randomAddress();
+        const mockBeneficiary = randomAddress();
+        const mockOracleAddress = randomAddress();
+        const feeToken = randomAddress();
+        const domainId = test1.domainId;
+        stubIgpPackageVersion(missingSelectorError());
+        sandbox.stub(evmHookReader, 'possibleDomainIds').returns([domainId]);
+        const mockIgp = {
+            hookType: sandbox
+                .stub()
+                .resolves(OnchainHookType.INTERCHAIN_GAS_PAYMASTER),
+            owner: sandbox.stub().resolves(mockOwner),
+            beneficiary: sandbox.stub().resolves(mockBeneficiary),
+            quoteSigners: sandbox
+                .stub()
+                .rejects(new Error('quoteSigners must not be called on a legacy IGP')),
+            getExchangeRateAndGasPrice: sandbox
+                .stub()
+                .rejects(new Error(`Configured IGP doesn't support domain ${domainId}`)),
+            destinationGasLimit: sandbox.stub().resolves(ethers.BigNumber.from(0)),
+            destinationGasConfigs: sandbox.stub().resolves({
+                gasOracle: mockOracleAddress,
+                gasOverhead: ethers.BigNumber.from(0),
+            }),
+            tokenGasOracles: sandbox.stub().resolves(mockOracleAddress), // non-zero oracle for all calls
+        };
+        sandbox
+            .stub(InterchainGasPaymaster__factory, 'connect')
+            .returns(mockIgp);
+        sandbox
+            .stub(IPostDispatchHook__factory, 'connect')
+            .returns(mockIgp);
+        const mockOracle = {
+            owner: sandbox.stub().resolves(mockOwner),
+            remoteGasData: sandbox.stub().resolves({
+                tokenExchangeRate: ethers.BigNumber.from('15000000000'),
+                gasPrice: ethers.BigNumber.from('500000000'),
+            }),
+        };
+        sandbox
+            .stub(StorageGasOracle__factory, 'connect')
+            .returns(mockOracle);
+        const config = await evmHookReader.deriveIgpConfig(mockAddress, [feeToken]);
+        expect(mockOracle.remoteGasData.calledOnce).to.be.true;
+        expect(config.tokenOracleConfig).to.deep.equal({
+            [feeToken]: {
+                [test1.name]: {
+                    tokenExchangeRate: '15000000000',
+                    gasPrice: '500000000',
+                    tokenDecimals: test1.nativeToken?.decimals,
+                },
+            },
+        });
+    });
+    /*
+      Testing for more nested hook types can be done manually by reading from existing contracts onchain.
+      Examples of nested hook types include:
+      - Aggregation
+      - Domain Routing
+      - Fallback Domain Routing
+      - Interchain Gas Paymaster
+    */
+});
+//# sourceMappingURL=EvmHookReader.test.js.map