token-2022 transfer-hook counter: reuse the existing counter when configuring another mint

Author: MarkFeder

tokens/token-2022/transfer-hook/counter/pinocchio/program/src/instructions/initialize_extra_account_meta_list.rs

@@ -7,7 +7,10 @@ use pinocchio::{
 use pinocchio_log::log;
 use pinocchio_system::instructions::CreateAccount;
 
-use crate::instructions::{COUNTER_SEED, COUNTER_SIZE, EXTRA_ACCOUNT_METAS_SEED};
+use crate::{
+    error::TransferHookError,
+    instructions::{COUNTER_SEED, COUNTER_SIZE, EXTRA_ACCOUNT_METAS_SEED},
+};
 
 /// A serialized `ExtraAccountMetaList` holding this example's one extra
 /// account: the counter PDA.
@@ -108,18 +111,26 @@ pub fn initialize_extra_account_meta_list(program_id: &Address, accounts: &mut [
         return Err(ProgramError::InvalidSeeds);
     }
 
-    let counter_bump_bytes = [counter_bump];
-    let counter_seeds = [Seed::from(COUNTER_SEED), Seed::from(&counter_bump_bytes)];
+    // Because that counter is global rather than per-mint, setting up a second
+    // mint finds it already there. Creating it again would fail and take the
+    // whole instruction — including the new mint's list — down with it, so the
+    // existing account is reused instead.
+    if counter.is_data_empty() {
+        let counter_bump_bytes = [counter_bump];
+        let counter_seeds = [Seed::from(COUNTER_SEED), Seed::from(&counter_bump_bytes)];
 
-    log!("Creating counter");
-    CreateAccount {
-        from: payer,
-        to: counter,
-        lamports: Rent::get()?.try_minimum_balance(COUNTER_SIZE)?,
-        space: COUNTER_SIZE as u64,
-        owner: program_id,
+        log!("Creating counter");
+        CreateAccount {
+            from: payer,
+            to: counter,
+            lamports: Rent::get()?.try_minimum_balance(COUNTER_SIZE)?,
+            space: COUNTER_SIZE as u64,
+            owner: program_id,
+        }
+        .invoke_signed(&[Signer::from(&counter_seeds)])?;
+    } else if !counter.owned_by(program_id) || counter.data_len() != COUNTER_SIZE {
+        return Err(TransferHookError::InvalidCounterAccount.into());
     }
-    .invoke_signed(&[Signer::from(&counter_seeds)])?;
 
     log!("Extra account meta list created");
     Ok(())

tokens/token-2022/transfer-hook/counter/pinocchio/tests/test.ts

@@ -361,6 +361,54 @@ describe('Token-2022 Transfer Hook — Counter (Pinocchio)', () => {
         assert.equal(counterValue(), 2n, 'the counter advanced to two');
     });
 
+    it('Configures a second mint against the existing counter', async () => {
+        // The counter is global, not per-mint, so setting up a second mint must
+        // reuse it. Creating it again would fail and roll the whole setup back,
+        // leaving every mint after the first unable to use this hook.
+        const secondMint = await generateKeyPairSigner();
+        const initIx = {
+            programAddress: programId,
+            accounts: [
+                { address: payer.address, role: AccountRole.WRITABLE_SIGNER, signer: payer },
+                { address: secondMint.address, role: AccountRole.WRITABLE_SIGNER, signer: secondMint },
+                { address: TOKEN_2022_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+                { address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+            ],
+            data: Uint8Array.of(INITIALIZE_DISCRIMINATOR, DECIMALS),
+        };
+        send(await tx([initIx]), 'initialize second mint');
+
+        const [secondMetaList] = await getProgramDerivedAddress({
+            programAddress: programId,
+            seeds: ['extra-account-metas', addressEncoder.encode(secondMint.address)],
+        });
+        const countBefore = counterValue();
+
+        const metasIx = {
+            programAddress: programId,
+            accounts: [
+                { address: payer.address, role: AccountRole.WRITABLE_SIGNER, signer: payer },
+                { address: secondMetaList, role: AccountRole.WRITABLE },
+                { address: secondMint.address, role: AccountRole.READONLY },
+                { address: counter, role: AccountRole.WRITABLE },
+                { address: TOKEN_2022_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+                { address: ASSOCIATED_TOKEN_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+                { address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+            ],
+            data: INITIALIZE_EXTRA_ACCOUNT_META_LIST_DISCRIMINATOR,
+        };
+        send(await tx([metasIx]), 'initialize second extra account meta list');
+
+        const account = svm.getAccount(secondMetaList);
+        if (!account?.exists) throw new Error('second extra account meta list not found');
+        assert.deepEqual(
+            Array.from(account.data),
+            Array.from(EXPECTED_EXTRA_ACCOUNT_METAS),
+            'the second mint got its own list',
+        );
+        assert.equal(counterValue(), countBefore, 'the shared counter kept its value');
+    });
+
     it('Rejects calling the hook outside a transfer', async () => {
         // Same accounts Token-2022 would pass, but invoked directly. The source
         // account's `transferring` flag is only set mid-transfer, so this fails.