fix: Enhance token batch instruction tests

Author: askov

app/features/token-batch/lib/__tests__/batch-parser.test.ts

@@ -7,7 +7,17 @@ import { concatBytes, writeU64LE } from '@/app/shared/lib/bytes';
 import { isTokenBatchInstruction, parseBatchInstruction } from '../batch-parser';
 import { BATCH_DISCRIMINATOR } from '../const';
 import { decodeSubInstructionParams } from '../decode-sub-instruction';
-import { buildBatchData, makeAccount, makeTransferCheckedData, makeTransferData } from './test-utils';
+import {
+    buildBatchData,
+    makeAccount,
+    makeApproveCheckedData,
+    makeApproveData,
+    makeBurnCheckedData,
+    makeMintToCheckedData,
+    makeSetAuthorityData,
+    makeTransferCheckedData,
+    makeTransferData,
+} from './test-utils';
 
 describe('isTokenBatchInstruction', () => {
     it('should detect batch instruction for Token Program', () => {
@@ -296,4 +306,105 @@ describe('decodeSubInstructionParams', () => {
         const data = new Uint8Array([]);
         expect(decodeSubInstructionParams('CloseAccount', data, [])).toBeUndefined();
     });
+
+    it('should decode Approve params', () => {
+        const data = makeApproveData(500n);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('Approve', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([{ label: 'Amount', value: '500' }]);
+        expect(decoded.accounts.map(a => a.label)).toEqual(['Source', 'Delegate', 'Owner']);
+    });
+
+    it('should decode ApproveChecked params', () => {
+        const data = makeApproveCheckedData(2000000n, 6);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('ApproveChecked', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([
+            { label: 'Amount', value: '2' },
+            { label: 'Decimals', value: '6' },
+        ]);
+        expect(decoded.accounts.map(a => a.label)).toEqual(['Source', 'Mint', 'Delegate', 'Owner']);
+    });
+
+    it('should decode MintToChecked params', () => {
+        const data = makeMintToCheckedData(50000000n, 8);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('MintToChecked', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([
+            { label: 'Amount', value: '0.5' },
+            { label: 'Decimals', value: '8' },
+        ]);
+        expect(decoded.accounts.map(a => a.label)).toEqual(['Mint', 'Destination', 'Mint Authority']);
+    });
+
+    it('should decode BurnChecked params', () => {
+        const data = makeBurnCheckedData(1500000000n, 9);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('BurnChecked', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([
+            { label: 'Amount', value: '1.5' },
+            { label: 'Decimals', value: '9' },
+        ]);
+        expect(decoded.accounts.map(a => a.label)).toEqual(['Account', 'Mint', 'Owner/Delegate']);
+    });
+
+    it('should decode SetAuthority with new authority set to None', () => {
+        const data = makeSetAuthorityData(1);
+        const accounts = [makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('SetAuthority', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([
+            { label: 'Authority Type', value: 'FreezeAccount' },
+            { label: 'New Authority', value: '(none)' },
+        ]);
+        expect(decoded.accounts.map(a => a.label)).toEqual(['Account', 'Current Authority']);
+    });
+
+    it('should decode SetAuthority with new authority set to Some', () => {
+        const newAuth = Keypair.generate().publicKey;
+        const data = makeSetAuthorityData(0, newAuth);
+        const accounts = [makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('SetAuthority', data, accounts);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([
+            { label: 'Authority Type', value: 'MintTokens' },
+            { label: 'New Authority', value: newAuth.toBase58() },
+        ]);
+    });
+
+    it('should format Transfer amount with decimals when provided', () => {
+        const data = makeTransferData(1500000n);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('Transfer', data, accounts, 6);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([{ label: 'Amount', value: '1.5' }]);
+    });
+
+    it('should format Approve amount with decimals when provided', () => {
+        const data = makeApproveData(25000000n);
+        const accounts = [makeAccount(), makeAccount(), makeAccount(false, true)];
+
+        const decoded = decodeSubInstructionParams('Approve', data, accounts, 8);
+
+        if (!decoded) throw new Error('Expected decoded to be defined');
+        expect(decoded.fields).toEqual([{ label: 'Amount', value: '0.25' }]);
+    });
 });

app/features/token-batch/lib/__tests__/test-utils.ts

@@ -31,6 +31,26 @@ export function makeTransferCheckedData(amount: bigint, decimals: number): Uint8
     return concatBytes(new Uint8Array([12]), writeU64LE(amount), new Uint8Array([decimals]));
 }
 
+export function makeApproveData(amount: bigint): Uint8Array {
+    return concatBytes(new Uint8Array([4]), writeU64LE(amount));
+}
+
+export function makeApproveCheckedData(amount: bigint, decimals: number): Uint8Array {
+    return concatBytes(new Uint8Array([13]), writeU64LE(amount), new Uint8Array([decimals]));
+}
+
+export function makeMintToCheckedData(amount: bigint, decimals: number): Uint8Array {
+    return concatBytes(new Uint8Array([14]), writeU64LE(amount), new Uint8Array([decimals]));
+}
+
+export function makeBurnData(amount: bigint): Uint8Array {
+    return concatBytes(new Uint8Array([8]), writeU64LE(amount));
+}
+
+export function makeBurnCheckedData(amount: bigint, decimals: number): Uint8Array {
+    return concatBytes(new Uint8Array([15]), writeU64LE(amount), new Uint8Array([decimals]));
+}
+
 // SetAuthority: [discriminator(6), authority_type(u8), option_tag(u8), ?new_authority(32)]
 export function makeSetAuthorityData(authorityType: number, newAuthority?: PublicKey): Uint8Array {
     if (newAuthority) {