add createsplinterface to token-interface sdk

Author: SwenSchaeferjohann

js/token-interface/package.json

@@ -49,7 +49,6 @@
         "buffer": "6.0.3"
     },
     "devDependencies": {
-        "@lightprotocol/compressed-token": "workspace:*",
         "@eslint/js": "9.36.0",
         "@rollup/plugin-commonjs": "^26.0.1",
         "@rollup/plugin-node-resolve": "^15.2.3",

js/token-interface/src/instructions/index.ts

@@ -7,3 +7,4 @@ export * from './load';
 export * from './burn';
 export * from './freeze';
 export * from './thaw';
+export * from './spl-interface';

js/token-interface/src/instructions/spl-interface.ts

@@ -0,0 +1,87 @@
+import {
+    AccountMeta,
+    PublicKey,
+    SystemProgram,
+    TransactionInstruction,
+} from '@solana/web3.js';
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { Buffer } from 'buffer';
+import {
+    COMPRESSED_TOKEN_PROGRAM_ID,
+    deriveCpiAuthorityPda,
+    deriveSplInterfacePdaWithIndex,
+} from '../constants';
+
+const CREATE_SPL_INTERFACE_DISCRIMINATOR = Buffer.from([
+    23, 169, 27, 122, 147, 169, 209, 152,
+]);
+
+interface CreateSplInterfaceAccountsLayoutParams {
+    feePayer: PublicKey;
+    mint: PublicKey;
+    splInterfacePda: PublicKey;
+    tokenProgramId: PublicKey;
+    cpiAuthorityPda: PublicKey;
+}
+
+function createSplInterfaceAccountsLayout({
+    feePayer,
+    mint,
+    splInterfacePda,
+    tokenProgramId,
+    cpiAuthorityPda,
+}: CreateSplInterfaceAccountsLayoutParams): AccountMeta[] {
+    return [
+        { pubkey: feePayer, isSigner: true, isWritable: true },
+        { pubkey: splInterfacePda, isSigner: false, isWritable: true },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: tokenProgramId, isSigner: false, isWritable: false },
+        { pubkey: cpiAuthorityPda, isSigner: false, isWritable: false },
+    ];
+}
+
+export interface CreateSplInterfaceInstructionInput {
+    feePayer: PublicKey;
+    mint: PublicKey;
+    index: number;
+    tokenProgramId?: PublicKey;
+}
+
+/**
+ * Create SPL interface (omnibus account) for an existing SPL mint.
+ *
+ * @param input                SPL interface instruction input.
+ * @param input.feePayer       Fee payer.
+ * @param input.mint           SPL mint address.
+ * @param input.index          SPL interface derivation index (single required index).
+ * @param input.tokenProgramId Token program id (defaults to TOKEN_PROGRAM_ID).
+ * @returns Create SPL interface instruction.
+ */
+export function createSplInterfaceInstruction({
+    feePayer,
+    mint,
+    index,
+    tokenProgramId = TOKEN_PROGRAM_ID,
+}: CreateSplInterfaceInstructionInput): TransactionInstruction {
+    if (!Number.isInteger(index) || index < 0 || index > 255) {
+        throw new Error(
+            `Invalid SPL interface index ${index}. Expected integer in [0, 255].`,
+        );
+    }
+
+    const [splInterfacePda] = deriveSplInterfacePdaWithIndex(mint, index);
+    const keys = createSplInterfaceAccountsLayout({
+        feePayer,
+        mint,
+        splInterfacePda,
+        tokenProgramId,
+        cpiAuthorityPda: deriveCpiAuthorityPda(),
+    });
+
+    return new TransactionInstruction({
+        programId: COMPRESSED_TOKEN_PROGRAM_ID,
+        keys,
+        data: CREATE_SPL_INTERFACE_DISCRIMINATOR,
+    });
+}

js/token-interface/src/kit/index.ts

@@ -12,11 +12,13 @@ import {
     createLoadInstructions as createLoadInstructionsTx,
     createRevokeInstructions as createRevokeInstructionsTx,
     createRevokeInstructionsNowrap as createRevokeInstructionsNowrapTx,
+    createSplInterfaceInstruction as createSplInterfaceInstructionTx,
     createThawInstructions as createThawInstructionsTx,
     createThawInstructionsNowrap as createThawInstructionsNowrapTx,
 } from '../instructions';
 import type { KitInstruction } from '../instructions/_plan';
 import { toKitInstructions } from '../instructions/_plan';
+import type { CreateSplInterfaceInstructionInput } from '../instructions/spl-interface';
 import type {
     CreateApproveInstructionsInput,
     CreateAtaInstructionsInput,
@@ -133,13 +135,20 @@ export async function createBurnInstructionsNowrap(
     return wrap(createBurnInstructionsNowrapTx(input));
 }
 
+export function createSplInterfaceInstruction(
+    input: CreateSplInterfaceInstructionInput,
+): KitInstruction {
+    return toKitInstructions([createSplInterfaceInstructionTx(input)])[0];
+}
+
 export type {
     CreateApproveInstructionsInput,
     CreateAtaInstructionsInput,
     CreateBurnInstructionsInput,
     CreateFreezeInstructionsInput,
     CreateLoadInstructionsInput,
     CreateRevokeInstructionsInput,
+    CreateSplInterfaceInstructionInput,
     CreateThawInstructionsInput,
     CreateTransferInstructionsInput,
 };

js/token-interface/tests/e2e/helpers.ts

@@ -17,7 +17,7 @@ import {
     selectStateTreeInfo,
     sendAndConfirmTx,
 } from '@lightprotocol/stateless.js';
-import { createMint, mintTo } from '@lightprotocol/compressed-token';
+import { createMint, mintTo } from '../../../compressed-token/src';
 import { parseLightTokenHot } from '../../src/read';
 import { getSplInterfaces } from '../../src/spl-interface';
 

js/token-interface/tests/unit/instruction-builders.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import { Keypair } from '@solana/web3.js';
+import { Keypair, SystemProgram } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { LIGHT_TOKEN_PROGRAM_ID, bn } from '@lightprotocol/stateless.js';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 import {
     createApproveInstruction,
     createAtaInstruction,
@@ -14,7 +14,13 @@ import {
     createThawInstruction,
     createTransferCheckedInstruction,
     createDecompressInstruction,
+    createSplInterfaceInstruction,
 } from '../../src/instructions';
+import {
+    COMPRESSED_TOKEN_PROGRAM_ID,
+    deriveCpiAuthorityPda,
+    deriveSplInterfacePdaWithIndex,
+} from '../../src/constants';
 
 describe('instruction builders', () => {
     function buildParsedCompressedAccount(params?: {
@@ -349,4 +355,72 @@ describe('instruction builders', () => {
         expect(instruction.keys[2].pubkey.equals(owner)).toBe(true);
         expect(instruction.keys[2].isSigner).toBe(true);
     });
+
+    it('creates spl interface instruction with required index', () => {
+        const feePayer = Keypair.generate().publicKey;
+        const mint = Keypair.generate().publicKey;
+        const index = 0;
+
+        const instruction = createSplInterfaceInstruction({
+            feePayer,
+            mint,
+            index,
+        });
+
+        const [splInterfacePda] = deriveSplInterfacePdaWithIndex(mint, index);
+
+        expect(instruction.programId.equals(COMPRESSED_TOKEN_PROGRAM_ID)).toBe(
+            true,
+        );
+        expect(
+            instruction.data.equals(
+                Buffer.from([23, 169, 27, 122, 147, 169, 209, 152]),
+            ),
+        ).toBe(true);
+        expect(instruction.keys).toHaveLength(6);
+        expect(instruction.keys[0].pubkey.equals(feePayer)).toBe(true);
+        expect(instruction.keys[0].isSigner).toBe(true);
+        expect(instruction.keys[0].isWritable).toBe(true);
+        expect(instruction.keys[1].pubkey.equals(splInterfacePda)).toBe(true);
+        expect(instruction.keys[1].isWritable).toBe(true);
+        expect(instruction.keys[2].pubkey.equals(SystemProgram.programId)).toBe(
+            true,
+        );
+        expect(instruction.keys[3].pubkey.equals(mint)).toBe(true);
+        expect(instruction.keys[3].isWritable).toBe(true);
+        expect(instruction.keys[4].pubkey.equals(TOKEN_PROGRAM_ID)).toBe(true);
+        expect(instruction.keys[5].pubkey.equals(deriveCpiAuthorityPda())).toBe(
+            true,
+        );
+    });
+
+    it('creates spl interface instruction with custom token program', () => {
+        const feePayer = Keypair.generate().publicKey;
+        const mint = Keypair.generate().publicKey;
+        const index = 1;
+
+        const instruction = createSplInterfaceInstruction({
+            feePayer,
+            mint,
+            index,
+            tokenProgramId: TOKEN_2022_PROGRAM_ID,
+        });
+
+        expect(
+            instruction.keys[4].pubkey.equals(TOKEN_2022_PROGRAM_ID),
+        ).toBe(true);
+    });
+
+    it('throws when spl interface index is out of range', () => {
+        const feePayer = Keypair.generate().publicKey;
+        const mint = Keypair.generate().publicKey;
+
+        expect(() =>
+            createSplInterfaceInstruction({
+                feePayer,
+                mint,
+                index: 256,
+            }),
+        ).toThrow(/integer in \[0, 255\]/i);
+    });
 });

js/token-interface/tests/unit/kit.test.ts

@@ -4,6 +4,7 @@ import { createAtaInstruction } from '../../src/instructions';
 import {
     createTransferInstructions,
     createAtaInstructions,
+    createSplInterfaceInstruction,
     createTransferInstructionPlan,
     toKitInstructions,
 } from '../../src/kit';
@@ -38,4 +39,15 @@ describe('kit adapter', () => {
         expect(typeof createTransferInstructions).toBe('function');
         expect(typeof createTransferInstructionPlan).toBe('function');
     });
+
+    it('adapts createSplInterfaceInstruction to kit format', () => {
+        const instruction = createSplInterfaceInstruction({
+            feePayer: Keypair.generate().publicKey,
+            mint: Keypair.generate().publicKey,
+            index: 0,
+        });
+
+        expect(instruction).toBeDefined();
+        expect(typeof instruction).toBe('object');
+    });
 });

js/token-interface/tests/unit/public-api.test.ts

@@ -8,6 +8,7 @@ import {
     createAtaInstructions,
     createFreezeInstruction,
     createThawInstruction,
+    createSplInterfaceInstruction,
     getAtaAddress,
 } from '../../src';
 
@@ -74,4 +75,8 @@ describe('public api', () => {
     it('exports canonical transfer builder', () => {
         expect(typeof createTransferInstructions).toBe('function');
     });
+
+    it('exports createSplInterfaceInstruction builder', () => {
+        expect(typeof createSplInterfaceInstruction).toBe('function');
+    });
 });