@hyperlane-xyz/sdk
Version:
The official SDK for the Hyperlane Network
74 lines • 3.49 kB
JavaScript
import { HypERC20Collateral__factory, HypERC20__factory, HypXERC20Lockbox__factory, TokenRouter__factory, } from '@hyperlane-xyz/core';
import { expect } from 'chai';
import { testChainMetadata } from '../../consts/testChains.js';
import { MultiProtocolProvider } from '../../providers/MultiProtocolProvider.js';
import { missingSelectorError, networkError } from '../../test/errors.js';
import { stubMultiProtocolProvider } from '../../test/multiProviderStubs.js';
import { EvmHypSyntheticAdapter, EvmHypXERC20LockboxAdapter, } from './EvmTokenAdapter.js';
describe('EvmHypXERC20LockboxAdapter', () => {
let sandbox;
let multiProvider;
const chainName = 'test1';
const hypTokenAddress = '0x1111111111111111111111111111111111111111';
const wrappedTokenAddress = '0x2222222222222222222222222222222222222222';
beforeEach(() => {
multiProvider = new MultiProtocolProvider(testChainMetadata);
sandbox = stubMultiProtocolProvider(multiProvider);
sandbox.stub(HypERC20__factory, 'connect').returns({});
sandbox.stub(TokenRouter__factory, 'connect').returns({});
});
afterEach(() => {
sandbox.restore();
});
it('loads wrapped token from lockbox contract', async () => {
const collateralWrappedToken = sandbox
.stub()
.rejects(new Error('collateral wrappedToken should not be called'));
sandbox.stub(HypERC20Collateral__factory, 'connect').returns({
wrappedToken: collateralWrappedToken,
});
const lockboxWrappedToken = sandbox.stub().resolves(wrappedTokenAddress);
sandbox.stub(HypXERC20Lockbox__factory, 'connect').returns({
wrappedToken: lockboxWrappedToken,
lockbox: sandbox
.stub()
.resolves('0x3333333333333333333333333333333333333333'),
xERC20: sandbox
.stub()
.resolves('0x4444444444444444444444444444444444444444'),
});
const adapter = new EvmHypXERC20LockboxAdapter(chainName, multiProvider, {
token: hypTokenAddress,
});
const wrapped = await adapter.getWrappedTokenAddress();
expect(wrapped).to.equal(wrappedTokenAddress);
expect(lockboxWrappedToken.calledOnce).to.equal(true);
expect(collateralWrappedToken.called).to.equal(false);
});
it('falls back to the legacy package version when PACKAGE_VERSION is missing', async () => {
const adapter = new EvmHypSyntheticAdapter(chainName, multiProvider, { token: hypTokenAddress }, {
connect: sandbox.stub().returns({
PACKAGE_VERSION: sandbox.stub().rejects(missingSelectorError()),
}),
});
const version = await adapter.getContractPackageVersion();
expect(version).to.equal('5.3.9');
});
it('throws transient package version probe failures', async () => {
const transientError = networkError();
const adapter = new EvmHypSyntheticAdapter(chainName, multiProvider, { token: hypTokenAddress }, {
connect: sandbox.stub().returns({
PACKAGE_VERSION: sandbox.stub().rejects(transientError),
}),
});
let thrown;
try {
await adapter.getContractPackageVersion();
}
catch (error) {
thrown = error;
}
expect(thrown).to.equal(transientError);
});
});
//# sourceMappingURL=EvmTokenAdapter.test.js.map