fix: reject alias creation when alias pair already exists

Adds a duplicate check in the alias writer's verify() step to return
a clear error instead of relying on the DB primary key constraint.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wa0x6e

src/writer/alias.ts

@@ -10,9 +10,18 @@ export async function verify(message): Promise<any> {
     log.warn(`[writer] Wrong alias format ${JSON.stringify(schemaIsValid)}`);
     return Promise.reject('wrong alias format');
   }
-  if (message.from === msg.payload.alias) {
+  if (message.address === msg.payload.alias) {
     return Promise.reject('alias cannot be the same as the address');
   }
+
+  const existing = await db.queryAsync(
+    'SELECT 1 FROM aliases WHERE address = ? AND alias = ? LIMIT 1',
+    [message.address, msg.payload.alias]
+  );
+  if (existing.length > 0) {
+    return Promise.reject('alias already exists');
+  }
+
   return true;
 }
 

test/integration/helpers/alias.test.ts

@@ -1,32 +1,58 @@
 import { isExistingAlias } from '../../../src/helpers/alias';
 import db, { sequencerDB } from '../../../src/helpers/mysql';
+import { verify } from '../../../src/writer/alias';
 import { aliasesSqlFixtures } from '../../fixtures/alias';
 
 describe('alias', () => {
   const seed = Date.now().toFixed(0);
 
-  beforeAll(async () => {
-    await db.queryAsync('DELETE from snapshot_sequencer_test.aliases');
+  beforeEach(async () => {
+    await db.queryAsync('DELETE from snapshot_sequencer_test.aliases WHERE ipfs = ?', seed);
     await Promise.all(
       aliasesSqlFixtures.map(alias => {
-        const values = {
-          ...alias,
-          ipfs: seed
-        };
-        return db.queryAsync('INSERT INTO snapshot_sequencer_test.aliases SET ?', values);
+        const values = { ...alias, ipfs: seed };
+        return db.queryAsync(
+          'INSERT INTO snapshot_sequencer_test.aliases SET ? ON DUPLICATE KEY UPDATE ipfs = VALUES(ipfs), created = VALUES(created)',
+          values
+        );
       })
     );
   });
 
-  afterEach(async () => {
-    await db.queryAsync('DELETE from snapshot_sequencer_test.aliases where ipfs = ?', seed);
-  });
-
   afterAll(async () => {
+    await db.queryAsync('DELETE from snapshot_sequencer_test.aliases WHERE ipfs = ?', seed);
     await db.endAsync();
     await sequencerDB.endAsync();
   });
 
+  describe('verify()', () => {
+    it('should reject when alias already exists', async () => {
+      const { address, alias } = aliasesSqlFixtures[0];
+      const msg = {
+        version: '0.1.4',
+        timestamp: Math.floor(Date.now() / 1000),
+        type: 'alias',
+        payload: { alias }
+      };
+
+      await expect(verify({ address, msg: JSON.stringify(msg) })).rejects.toMatch(
+        'alias already exists'
+      );
+    });
+
+    it('should pass when alias does not exist', async () => {
+      const address = '0x0000000000000000000000000000000000000001';
+      const msg = {
+        version: '0.1.4',
+        timestamp: Math.floor(Date.now() / 1000),
+        type: 'alias',
+        payload: { alias: '0x0000000000000000000000000000000000000002' }
+      };
+
+      await expect(verify({ address, msg: JSON.stringify(msg) })).resolves.toBeTruthy();
+    });
+  });
+
   describe('isExistingAlias()', () => {
     it('should return true for valid alias', () => {
       expect(

test/unit/writer/alias.test.ts

@@ -2,7 +2,7 @@ import * as writer from '../../../src/writer/alias';
 import input from '../../fixtures/writer-payload/alias.json';
 import omit from 'lodash/omit';
 
-describe('writer/profile', () => {
+describe('writer/alias', () => {
   describe('verify()', () => {
     const msg = JSON.parse(input.msg);
     const invalidMsg = [