@hyperlane-xyz/deploy-sdk 1.4.0 → 2.0.0

package/dist/warp/warp-writer.test.js

@@ -0,0 +1,903 @@
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import Sinon from 'sinon';
+import { ArtifactState } from '@hyperlane-xyz/provider-sdk/artifact';
+import { ProtocolType } from '@hyperlane-xyz/provider-sdk/protocol';
+import { TokenType, } from '@hyperlane-xyz/provider-sdk/warp';
+import { WarpTokenWriter } from './warp-writer.js';
+chai.use(chaiAsPromised);
+const TEST_CHAIN = 'test1';
+const TEST_DOMAIN_ID = 1;
+const REMOTE_DOMAIN_ID_1 = 1234;
+const REMOTE_DOMAIN_ID_2 = 4321;
+const REMOTE_DOMAIN_ID_3 = 5321;
+const TOKEN_ADDRESS = '0x726f757465725f61707000000000000000000000000000010000000000000000';
+const OWNER_ADDRESS = 'hyp1jq304cthpx0lwhpqzrdjrcza559ukyy3sc4dw5';
+const MAILBOX_ADDRESS = '0x68797065726c616e650000000000000000000000000000000000000000000000';
+const ISM_ADDRESS = '0x1234';
+const HOOK_ADDRESS = '0x5678';
+describe('WarpTokenWriter', () => {
+    let writer;
+    let mockArtifactManager;
+    let mockSigner;
+    let mockIsmWriter;
+    let mockHookWriter;
+    let mockChainLookup;
+    let readStub;
+    const actualConfig = {
+        type: TokenType.collateral,
+        owner: OWNER_ADDRESS,
+        mailbox: MAILBOX_ADDRESS,
+        token: 'uhyp',
+        remoteRouters: {
+            [REMOTE_DOMAIN_ID_1]: {
+                address: TOKEN_ADDRESS,
+            },
+        },
+        destinationGas: {
+            [REMOTE_DOMAIN_ID_1]: '200000',
+        },
+    };
+    const baseDeployedArtifact = {
+        artifactState: ArtifactState.DEPLOYED,
+        config: actualConfig,
+        deployed: { address: TOKEN_ADDRESS },
+    };
+    const chainMetadata = {
+        name: TEST_CHAIN,
+        chainId: 1,
+        domainId: TEST_DOMAIN_ID,
+        protocol: ProtocolType.Ethereum,
+        rpcUrls: [{ http: 'http://localhost:8545' }],
+    };
+    beforeEach(() => {
+        // Create mock artifact manager
+        mockArtifactManager = {
+            readWarpToken: Sinon.stub(),
+            createWriter: Sinon.stub(),
+            supportsHookUpdates: Sinon.stub().returns(true),
+        };
+        // Create minimal mock signer
+        mockSigner = {
+            getSignerAddress: () => OWNER_ADDRESS,
+        };
+        // Create mock chain lookup
+        mockChainLookup = {
+            getChainMetadata: Sinon.stub().returns({
+                name: TEST_CHAIN,
+                domainId: TEST_DOMAIN_ID,
+                protocol: ProtocolType.Ethereum,
+            }),
+            getChainName: Sinon.stub().returns(TEST_CHAIN),
+            getDomainId: Sinon.stub().returns(TEST_DOMAIN_ID),
+        };
+        // Create mock ISM and Hook writers FIRST
+        mockIsmWriter = {
+            create: Sinon.stub(),
+            update: Sinon.stub(),
+            read: Sinon.stub(),
+        };
+        mockHookWriter = {
+            create: Sinon.stub(),
+            update: Sinon.stub(),
+            read: Sinon.stub(),
+        };
+        // Create writer instance - manually to bypass protocol provider
+        writer = Object.create(WarpTokenWriter.prototype);
+        Object.assign(writer, {
+            artifactManager: mockArtifactManager,
+            chainMetadata,
+            chainLookup: mockChainLookup,
+            signer: mockSigner,
+            ismWriter: mockIsmWriter,
+            hookWriterFactory: () => mockHookWriter,
+        });
+        // Default read stub - returns current config
+        readStub = Sinon.stub(writer, 'read').resolves(baseDeployedArtifact);
+    });
+    afterEach(() => {
+        Sinon.restore();
+    });
+    describe('update() - Router Management', () => {
+        const createMockTx = (annotation) => ({
+            annotation,
+            to: TOKEN_ADDRESS,
+            data: '0x',
+        });
+        const routerTestCases = [
+            {
+                name: 'no updates needed if config is the same',
+                configOverrides: {},
+                expectedTxCount: 0,
+            },
+            {
+                name: 'new remote router',
+                configOverrides: {
+                    remoteRouters: {
+                        ...actualConfig.remoteRouters,
+                        [REMOTE_DOMAIN_ID_2]: { address: '0xNEWROUTER' },
+                    },
+                    destinationGas: {
+                        ...actualConfig.destinationGas,
+                        [REMOTE_DOMAIN_ID_2]: '300000',
+                    },
+                },
+                expectedTxCount: 1,
+                assertion: (txs) => {
+                    expect(txs[0].annotation).to.include('router');
+                },
+            },
+            {
+                name: 'multiple new remote routers',
+                configOverrides: {
+                    remoteRouters: {
+                        ...actualConfig.remoteRouters,
+                        [REMOTE_DOMAIN_ID_2]: { address: '0xNEWROUTER1' },
+                        [REMOTE_DOMAIN_ID_3]: { address: '0xNEWROUTER2' },
+                    },
+                    destinationGas: {
+                        ...actualConfig.destinationGas,
+                        [REMOTE_DOMAIN_ID_2]: '300000',
+                        [REMOTE_DOMAIN_ID_3]: '400000',
+                    },
+                },
+                expectedTxCount: 2,
+                assertion: (txs) => {
+                    expect(txs).to.have.lengthOf(2);
+                    txs.forEach((tx) => {
+                        expect(tx.annotation).to.include('router');
+                    });
+                },
+            },
+            {
+                name: 'remove existing remote router',
+                configOverrides: {
+                    remoteRouters: {},
+                    destinationGas: {},
+                },
+                expectedTxCount: 1,
+            },
+            {
+                name: 'update existing router address',
+                configOverrides: {
+                    remoteRouters: {
+                        [REMOTE_DOMAIN_ID_1]: { address: '0xUPDATEDROUTER' },
+                    },
+                },
+                expectedTxCount: 2, // unenroll + enroll
+            },
+            {
+                name: 'update existing router gas',
+                configOverrides: {
+                    destinationGas: {
+                        [REMOTE_DOMAIN_ID_1]: '999999',
+                    },
+                },
+                expectedTxCount: 2, // unenroll + enroll with new gas
+            },
+            {
+                name: 'remove and add remote router at the same time',
+                configOverrides: {
+                    remoteRouters: {
+                        [REMOTE_DOMAIN_ID_2]: { address: '0xNEWROUTER' },
+                    },
+                    destinationGas: {
+                        [REMOTE_DOMAIN_ID_2]: '300000',
+                    },
+                },
+                expectedTxCount: 2, // remove old + add new
+            },
+        ];
+        routerTestCases.forEach(({ name, configOverrides, expectedTxCount, assertion }) => {
+            it(name, async () => {
+                // Setup mock writer
+                const mockWriter = {
+                    read: Sinon.stub(),
+                    create: Sinon.stub(),
+                    update: Sinon.stub().resolves(Array(expectedTxCount)
+                        .fill(null)
+                        .map((_, i) => createMockTx(`Update router ${i}`))),
+                };
+                mockArtifactManager.createWriter.returns(mockWriter);
+                // Execute update
+                const artifact = {
+                    ...baseDeployedArtifact,
+                    config: { ...actualConfig, ...configOverrides },
+                };
+                const updateTxs = await writer.update(artifact);
+                // Assertions
+                expect(updateTxs).to.have.lengthOf(expectedTxCount);
+                if (assertion) {
+                    assertion(updateTxs);
+                }
+            });
+        });
+    });
+    describe('update() - Ownership Changes', () => {
+        it('should update ownership', async () => {
+            const newOwner = '0x9999999999999999999999999999999999999999';
+            const configWithNewOwner = {
+                ...actualConfig,
+                owner: newOwner,
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    {
+                        annotation: 'Transfer ownership',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithNewOwner,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(updateTxs).to.have.lengthOf(1);
+            expect(updateTxs[0].annotation).to.match(/ownership/i);
+        });
+    });
+    describe('update() - ISM Updates', () => {
+        const createIsmConfig = (type, validators) => ({
+            type,
+            validators,
+            threshold: 1,
+        });
+        it('should deploy new ISM', async () => {
+            const newIsmConfig = createIsmConfig('messageIdMultisigIsm', [
+                '0xVALIDATOR',
+            ]);
+            const configWithIsm = {
+                ...actualConfig,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.NEW,
+                    config: newIsmConfig,
+                },
+            };
+            // Mock ISM creation
+            const deployedIsm = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: newIsmConfig,
+                deployed: { address: ISM_ADDRESS },
+            };
+            mockIsmWriter.create.resolves([deployedIsm, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    {
+                        annotation: 'Set ISM',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithIsm,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.be.greaterThan(0);
+        });
+        it('should update existing ISM in-place when type is unchanged', async () => {
+            const ismConfig = createIsmConfig('messageIdMultisigIsm', [
+                '0xVALIDATOR1',
+            ]);
+            const currentArtifactWithIsm = {
+                ...baseDeployedArtifact,
+                config: {
+                    ...actualConfig,
+                    interchainSecurityModule: {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: ismConfig,
+                        deployed: { address: ISM_ADDRESS },
+                    },
+                },
+            };
+            readStub.restore();
+            readStub = Sinon.stub(writer, 'read').resolves(currentArtifactWithIsm);
+            mockIsmWriter.update.resolves([]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: {
+                    ...actualConfig,
+                    interchainSecurityModule: {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: ismConfig,
+                        deployed: { address: ISM_ADDRESS },
+                    },
+                },
+            };
+            await writer.update(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(0);
+            expect(mockIsmWriter.update.callCount).to.equal(1);
+        });
+        it('should replace existing ISM when type changes', async () => {
+            // Setup current artifact with existing ISM
+            const currentIsmConfig = createIsmConfig('messageIdMultisigIsm', [
+                '0xVALIDATOR1',
+            ]);
+            const currentArtifactWithIsm = {
+                ...baseDeployedArtifact,
+                config: {
+                    ...actualConfig,
+                    interchainSecurityModule: {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: currentIsmConfig,
+                        deployed: { address: ISM_ADDRESS },
+                    },
+                },
+            };
+            readStub.restore();
+            readStub = Sinon.stub(writer, 'read').resolves(currentArtifactWithIsm);
+            // New ISM config
+            const newIsmConfig = {
+                type: 'merkleRootMultisigIsm',
+                validators: ['0xVALIDATOR2'],
+                threshold: 1,
+            };
+            const configWithNewIsm = {
+                ...actualConfig,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.NEW,
+                    config: newIsmConfig,
+                },
+            };
+            // Mock ISM creation (new ISM type)
+            const newIsmAddress = '0x0000000000000000000000000000000000000004';
+            const deployedNewIsm = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: newIsmConfig,
+                deployed: { address: newIsmAddress },
+            };
+            mockIsmWriter.create.resolves([deployedNewIsm, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    {
+                        annotation: 'Update ISM',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithNewIsm,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.be.greaterThan(0);
+        });
+        it('should treat omitted ISM and zero-address ISM equivalently', async () => {
+            const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            // Case 1: no ISM
+            const artifactNoIsm = {
+                ...baseDeployedArtifact,
+                config: { ...actualConfig, interchainSecurityModule: undefined },
+            };
+            await writer.update(artifactNoIsm);
+            const createCountAfterNoIsm = mockIsmWriter.create.callCount;
+            // Case 2: zero-address ISM (UNDERIVED — treated as pass-through)
+            const artifactZeroIsm = {
+                ...baseDeployedArtifact,
+                config: {
+                    ...actualConfig,
+                    interchainSecurityModule: {
+                        artifactState: ArtifactState.UNDERIVED,
+                        deployed: { address: ZERO_ADDRESS },
+                    },
+                },
+            };
+            await writer.update(artifactZeroIsm);
+            // Neither case should trigger ISM creation
+            expect(mockIsmWriter.create.callCount).to.equal(createCountAfterNoIsm);
+            expect(mockIsmWriter.create.callCount).to.equal(0);
+        });
+    });
+    describe('update() - Hook Updates', () => {
+        const merkleTreeHookConfig = {
+            type: 'merkleTreeHook',
+        };
+        it('should deploy new hook when none existed before', async () => {
+            const configWithHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.NEW,
+                    config: merkleTreeHookConfig,
+                },
+            };
+            const deployedHook = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: merkleTreeHookConfig,
+                deployed: { address: HOOK_ADDRESS },
+            };
+            mockHookWriter.create.resolves([deployedHook, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    { annotation: 'Set hook', to: TOKEN_ADDRESS, data: '0x' },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithHook,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockHookWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.be.greaterThan(0);
+        });
+        it('should skip hook deployment when hook is underived (address reference)', async () => {
+            const configWithUnderivedHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.UNDERIVED,
+                    deployed: { address: HOOK_ADDRESS },
+                },
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithUnderivedHook,
+            };
+            await writer.update(artifact);
+            expect(mockHookWriter.create.called).to.be.false;
+            expect(mockHookWriter.update.called).to.be.false;
+        });
+        it('should skip hook deployment when protocol does not support hook updates', async () => {
+            mockArtifactManager.supportsHookUpdates.returns(false);
+            const configWithHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.NEW,
+                    config: merkleTreeHookConfig,
+                },
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithHook,
+            };
+            await writer.update(artifact);
+            expect(mockHookWriter.create.called).to.be.false;
+            expect(mockHookWriter.update.called).to.be.false;
+        });
+        it('should handle hook + router updates in single call', async () => {
+            const configWithHookAndRouter = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.NEW,
+                    config: merkleTreeHookConfig,
+                },
+                remoteRouters: {
+                    ...actualConfig.remoteRouters,
+                    [REMOTE_DOMAIN_ID_2]: { address: '0xNEWROUTER' },
+                },
+                destinationGas: {
+                    ...actualConfig.destinationGas,
+                    [REMOTE_DOMAIN_ID_2]: '300000',
+                },
+            };
+            const deployedHook = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: merkleTreeHookConfig,
+                deployed: { address: HOOK_ADDRESS },
+            };
+            mockHookWriter.create.resolves([deployedHook, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    { annotation: 'Set hook', to: TOKEN_ADDRESS, data: '0x' },
+                    { annotation: 'Enroll router', to: TOKEN_ADDRESS, data: '0x' },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithHookAndRouter,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockHookWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.equal(2);
+        });
+    });
+    describe('update() - Validation', () => {
+        it('should reject changing token type', async () => {
+            // Current artifact is collateral
+            const currentArtifact = {
+                ...baseDeployedArtifact,
+                config: {
+                    ...actualConfig,
+                    type: TokenType.collateral,
+                },
+            };
+            readStub.restore();
+            readStub = Sinon.stub(writer, 'read').resolves(currentArtifact);
+            // Try to change to synthetic
+            const syntheticConfig = {
+                type: TokenType.synthetic,
+                owner: OWNER_ADDRESS,
+                mailbox: MAILBOX_ADDRESS,
+                name: 'Synthetic Token',
+                symbol: 'SYN',
+                decimals: 18,
+                remoteRouters: {},
+                destinationGas: {},
+            };
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: syntheticConfig,
+            };
+            await expect(writer.update(artifact)).to.be.rejectedWith(/Cannot change warp token type/);
+        });
+    });
+    describe('update() - Complex Scenarios', () => {
+        it('should handle ISM + router updates in single call', async () => {
+            const newIsmConfig = {
+                type: 'messageIdMultisigIsm',
+                validators: ['0xVALIDATOR'],
+                threshold: 1,
+            };
+            const configWithIsmAndRouter = {
+                ...actualConfig,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.NEW,
+                    config: newIsmConfig,
+                },
+                remoteRouters: {
+                    ...actualConfig.remoteRouters,
+                    [REMOTE_DOMAIN_ID_2]: { address: '0xNEWROUTER' },
+                },
+                destinationGas: {
+                    ...actualConfig.destinationGas,
+                    [REMOTE_DOMAIN_ID_2]: '300000',
+                },
+            };
+            // Mock ISM creation
+            const deployedIsm = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: newIsmConfig,
+                deployed: { address: ISM_ADDRESS },
+            };
+            mockIsmWriter.create.resolves([deployedIsm, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    {
+                        annotation: 'Set ISM',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                    {
+                        annotation: 'Enroll router',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: configWithIsmAndRouter,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.be.greaterThan(1);
+        });
+        it('should handle ownership + ISM + router updates', async () => {
+            const newOwner = '0x9999999999999999999999999999999999999999';
+            const newIsmConfig = {
+                type: 'messageIdMultisigIsm',
+                validators: ['0xVALIDATOR'],
+                threshold: 1,
+            };
+            const complexConfig = {
+                ...actualConfig,
+                owner: newOwner,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.NEW,
+                    config: newIsmConfig,
+                },
+                remoteRouters: {},
+                destinationGas: {},
+            };
+            // Mock ISM creation
+            const deployedIsm = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: newIsmConfig,
+                deployed: { address: ISM_ADDRESS },
+            };
+            mockIsmWriter.create.resolves([deployedIsm, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([
+                    {
+                        annotation: 'Transfer ownership',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                    {
+                        annotation: 'Set ISM',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                    {
+                        annotation: 'Unenroll router',
+                        to: TOKEN_ADDRESS,
+                        data: '0x',
+                    },
+                ]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: complexConfig,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(1);
+            expect(updateTxs.length).to.equal(3);
+        });
+    });
+    describe('create()', () => {
+        it('should create warp token without ISM', async () => {
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: actualConfig,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: actualConfig,
+            };
+            const [deployed, receipts] = await writer.create(artifact);
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+            expect(deployed.deployed.address).to.equal(TOKEN_ADDRESS);
+            expect(receipts).to.be.an('array');
+            expect(mockWriter.create.callCount).to.equal(1);
+        });
+        it('should create warp token with new ISM', async () => {
+            const newIsmConfig = {
+                type: 'messageIdMultisigIsm',
+                validators: ['0xVALIDATOR'],
+                threshold: 1,
+            };
+            const configWithIsm = {
+                ...actualConfig,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.NEW,
+                    config: newIsmConfig,
+                },
+            };
+            // Mock ISM creation
+            const deployedIsm = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: newIsmConfig,
+                deployed: { address: ISM_ADDRESS },
+            };
+            mockIsmWriter.create.resolves([deployedIsm, []]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: configWithIsm,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: configWithIsm,
+            };
+            const [deployed, receipts] = await writer.create(artifact);
+            expect(mockIsmWriter.create.callCount).to.equal(1);
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+            expect(deployed.deployed.address).to.equal(TOKEN_ADDRESS);
+            expect(receipts).to.be.an('array');
+        });
+        it('should create warp token with existing ISM', async () => {
+            const existingIsmConfig = {
+                type: 'messageIdMultisigIsm',
+                validators: ['0xVALIDATOR'],
+                threshold: 1,
+            };
+            const configWithExistingIsm = {
+                ...actualConfig,
+                interchainSecurityModule: {
+                    artifactState: ArtifactState.DEPLOYED,
+                    config: existingIsmConfig,
+                    deployed: { address: ISM_ADDRESS },
+                },
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: configWithExistingIsm,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: configWithExistingIsm,
+            };
+            const [deployed, receipts] = await writer.create(artifact);
+            // Should not create new ISM
+            expect(mockIsmWriter.create.called).to.be.false;
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+            expect(deployed.deployed.address).to.equal(TOKEN_ADDRESS);
+            expect(receipts).to.be.an('array');
+        });
+    });
+    describe('create() - Hook', () => {
+        const merkleTreeHookConfig = {
+            type: 'merkleTreeHook',
+        };
+        it('should deploy hook before warp token when hook is new', async () => {
+            const configWithHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.NEW,
+                    config: merkleTreeHookConfig,
+                },
+            };
+            const hookReceipt = { transactionHash: '0xHOOKTX' };
+            const deployedHook = {
+                artifactState: ArtifactState.DEPLOYED,
+                config: merkleTreeHookConfig,
+                deployed: { address: HOOK_ADDRESS },
+            };
+            mockHookWriter.create.resolves([deployedHook, [hookReceipt]]);
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: configWithHook,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: configWithHook,
+            };
+            const [deployed, receipts] = await writer.create(artifact);
+            expect(mockHookWriter.create.callCount).to.equal(1);
+            expect(receipts).to.include(hookReceipt);
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+            expect(deployed.deployed.address).to.equal(TOKEN_ADDRESS);
+        });
+        it('should reuse hook address when hook is already deployed', async () => {
+            const configWithDeployedHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.DEPLOYED,
+                    config: merkleTreeHookConfig,
+                    deployed: { address: HOOK_ADDRESS },
+                },
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: configWithDeployedHook,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: configWithDeployedHook,
+            };
+            const [deployed] = await writer.create(artifact);
+            expect(mockHookWriter.create.called).to.be.false;
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+        });
+        it('should skip hook deployment when protocol does not support hooks', async () => {
+            mockArtifactManager.supportsHookUpdates.returns(false);
+            const configWithHook = {
+                ...actualConfig,
+                hook: {
+                    artifactState: ArtifactState.NEW,
+                    config: merkleTreeHookConfig,
+                },
+            };
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub().resolves([
+                    {
+                        artifactState: ArtifactState.DEPLOYED,
+                        config: configWithHook,
+                        deployed: { address: TOKEN_ADDRESS },
+                    },
+                    [],
+                ]),
+                update: Sinon.stub(),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                artifactState: ArtifactState.NEW,
+                config: configWithHook,
+            };
+            const [deployed] = await writer.create(artifact);
+            expect(mockHookWriter.create.called).to.be.false;
+            expect(deployed.artifactState).to.equal(ArtifactState.DEPLOYED);
+        });
+    });
+    describe('update() - Idempotency', () => {
+        it('should return empty array when no changes needed', async () => {
+            const mockWriter = {
+                read: Sinon.stub(),
+                create: Sinon.stub(),
+                update: Sinon.stub().resolves([]),
+            };
+            mockArtifactManager.createWriter.returns(mockWriter);
+            const artifact = {
+                ...baseDeployedArtifact,
+                config: actualConfig,
+            };
+            const updateTxs = await writer.update(artifact);
+            expect(updateTxs).to.be.an('array').that.is.empty;
+        });
+    });
+});
+//# sourceMappingURL=warp-writer.test.js.map