InitializeImmutableOwner Instruction (#3068)

* initializeImmutableOwner Instruction

* Immutable Owner Testing

* immutable owner tests

* Creating Mint and Initializing Account

* Parameter Synchronization

* Documentation Update

Co-authored-by: Ronald Hood <[email protected]>

Author: ronald-hood-jr

token/js/src/extensions/extensionType.ts

@@ -3,6 +3,7 @@ import { Mint, MINT_SIZE } from '../state/mint';
 import { MULTISIG_SIZE } from '../state/multisig';
 import { ACCOUNT_TYPE_SIZE } from './accountType';
 import { MINT_CLOSE_AUTHORITY_SIZE } from './mintCloseAuthority';
+import { IMMUTABLE_OWNER_SIZE } from './immutableOwner';
 
 export enum ExtensionType {
     Uninitialized,
@@ -38,7 +39,7 @@ export function getTypeLen(e: ExtensionType): number {
         case ExtensionType.DefaultAccountState:
             return 1;
         case ExtensionType.ImmutableOwner:
-            return 0;
+            return IMMUTABLE_OWNER_SIZE;
         case ExtensionType.MemoTransfer:
             return 1;
         default:

token/js/src/extensions/immutableOwner.ts

@@ -0,0 +1,20 @@
+import { struct } from '@solana/buffer-layout';
+import { Account } from '../state/account';
+import { ExtensionType, getExtensionData } from './extensionType';
+
+/** ImmutableOwner as stored by the program */
+export interface ImmutableOwner {} // eslint-disable-line
+
+/** Buffer layout for de/serializing an account */
+export const ImmutableOwnerLayout = struct<ImmutableOwner>([]);
+
+export const IMMUTABLE_OWNER_SIZE = ImmutableOwnerLayout.span;
+
+export function getImmutableOwner(account: Account): ImmutableOwner | null {
+    const extensionData = getExtensionData(ExtensionType.ImmutableOwner, account.tlvData);
+    if (extensionData !== null) {
+        return ImmutableOwnerLayout.decode(extensionData);
+    } else {
+        return null;
+    }
+}

token/js/src/extensions/index.ts

@@ -1,3 +1,4 @@
 export * from './accountType';
 export * from './extensionType';
 export * from './mintCloseAuthority';
+export * from './immutableOwner';

token/js/src/instructions/index.ts

@@ -21,6 +21,7 @@ export * from './syncNative'; //          17
 export * from './initializeAccount3'; //  18
 export * from './initializeMultisig2'; // 19
 export * from './initializeMint2'; //     20
+export * from './initializeImmutableOwner'; //  22
 export * from './initializeMintCloseAuthority'; // 23
 export * from './createNativeMint'; //    29
 

token/js/src/instructions/initializeImmutableOwner.ts

@@ -0,0 +1,123 @@
+import { struct, u8 } from '@solana/buffer-layout';
+import { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import {
+    TokenInvalidInstructionDataError,
+    TokenInvalidInstructionKeysError,
+    TokenInvalidInstructionProgramError,
+    TokenInvalidInstructionTypeError,
+} from '../errors';
+import { TokenInstruction } from './types';
+
+/** Deserialized instruction for the initiation of an immutable owner account */
+export interface InitializeImmutableOwnerInstructionData {
+    instruction: TokenInstruction.InitializeImmutableOwner;
+}
+
+/** The struct that represents the instruction data as it is read by the program */
+export const initializeImmutableOwnerInstructionData = struct<InitializeImmutableOwnerInstructionData>([
+    u8('instruction'),
+]);
+
+/**
+ * Construct an InitializeImmutableOwner instruction
+ *
+ * @param account           Immutable Owner Account
+ * @param programId         SPL Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+export function createInitializeImmutableOwnerInstruction(
+    account: PublicKey,
+    programId: PublicKey
+): TransactionInstruction {
+    const keys = [{ pubkey: account, isSigner: false, isWritable: true }];
+
+    const data = Buffer.alloc(initializeImmutableOwnerInstructionData.span);
+    initializeImmutableOwnerInstructionData.encode(
+        {
+            instruction: TokenInstruction.InitializeImmutableOwner,
+        },
+        data
+    );
+
+    return new TransactionInstruction({ keys, programId, data });
+}
+
+/** A decoded, valid InitializeImmutableOwner instruction */
+export interface DecodedInitializeImmutableOwnerInstruction {
+    programId: PublicKey;
+    keys: {
+        account: AccountMeta;
+    };
+    data: {
+        instruction: TokenInstruction.InitializeImmutableOwner;
+    };
+}
+
+/**
+ * Decode an InitializeImmutableOwner instruction and validate it
+ *
+ * @param instruction InitializeImmutableOwner instruction to decode
+ * @param programId   SPL Token program account
+ *
+ * @return Decoded, valid instruction
+ */
+export function decodeInitializeImmutableOwnerInstruction(
+    instruction: TransactionInstruction,
+    programId: PublicKey
+): DecodedInitializeImmutableOwnerInstruction {
+    if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();
+    if (instruction.data.length !== initializeImmutableOwnerInstructionData.span)
+        throw new TokenInvalidInstructionDataError();
+
+    const {
+        keys: { account },
+        data,
+    } = decodeInitializeImmutableOwnerInstructionUnchecked(instruction);
+    if (data.instruction !== TokenInstruction.InitializeImmutableOwner) throw new TokenInvalidInstructionTypeError();
+    if (!account) throw new TokenInvalidInstructionKeysError();
+
+    return {
+        programId,
+        keys: {
+            account,
+        },
+        data,
+    };
+}
+
+/** A decoded, non-validated InitializeImmutableOwner instruction */
+export interface DecodedInitializeImmutableOwnerInstructionUnchecked {
+    programId: PublicKey;
+    keys: {
+        account: AccountMeta | undefined;
+    };
+    data: {
+        instruction: number;
+    };
+}
+
+/**
+ * Decode an InitializeImmutableOwner instruction without validating it
+ *
+ * @param instruction Transaction instruction to decode
+ *
+ * @return Decoded, non-validated instruction
+ */
+export function decodeInitializeImmutableOwnerInstructionUnchecked({
+    programId,
+    keys: [account],
+    data,
+}: TransactionInstruction): DecodedInitializeImmutableOwnerInstructionUnchecked {
+    const { instruction } = initializeImmutableOwnerInstructionData.decode(data);
+
+    return {
+        programId,
+        keys: {
+            account: account,
+        },
+        data: {
+            instruction,
+        },
+    };
+}

token/js/test/e2e-2022/immutableOwner.test.ts

@@ -0,0 +1,85 @@
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+chai.use(chaiAsPromised);
+
+import {
+    Connection,
+    Keypair,
+    PublicKey,
+    Signer,
+    SystemProgram,
+    Transaction,
+    sendAndConfirmTransaction,
+} from '@solana/web3.js';
+
+import {
+    AuthorityType,
+    setAuthority,
+    ExtensionType,
+    createInitializeImmutableOwnerInstruction,
+    createInitializeAccountInstruction,
+    createMint,
+    getAccountLen,
+} from '../../src';
+
+import { TEST_PROGRAM_ID, newAccountWithLamports, getConnection } from '../common';
+const TEST_TOKEN_DECIMALS = 2;
+const EXTENSIONS = [ExtensionType.ImmutableOwner];
+describe('immutableOwner', () => {
+    let connection: Connection;
+    let payer: Signer;
+    let owner: Keypair;
+    let account: PublicKey;
+    let mint: PublicKey;
+    before(async () => {
+        connection = await getConnection();
+        payer = await newAccountWithLamports(connection, 1000000000);
+    });
+    beforeEach(async () => {
+        const mintAuthority = Keypair.generate();
+        const mintKeypair = Keypair.generate();
+        mint = await createMint(
+            connection,
+            payer,
+            mintAuthority.publicKey,
+            mintAuthority.publicKey,
+            TEST_TOKEN_DECIMALS,
+            mintKeypair,
+            undefined,
+            TEST_PROGRAM_ID
+        );
+        owner = Keypair.generate();
+        const accountLen = getAccountLen(EXTENSIONS);
+        const lamports = await connection.getMinimumBalanceForRentExemption(accountLen);
+        const accountKeypair = Keypair.generate();
+        account = accountKeypair.publicKey;
+        const transaction = new Transaction().add(
+            SystemProgram.createAccount({
+                fromPubkey: payer.publicKey,
+                newAccountPubkey: account,
+                space: accountLen,
+                lamports,
+                programId: TEST_PROGRAM_ID,
+            }),
+            createInitializeImmutableOwnerInstruction(account, TEST_PROGRAM_ID),
+            createInitializeAccountInstruction(account, mint, owner.publicKey, TEST_PROGRAM_ID)
+        );
+        await sendAndConfirmTransaction(connection, transaction, [payer, accountKeypair], undefined);
+    });
+    it('AccountOwner', async () => {
+        const newOwner = Keypair.generate();
+        expect(
+            setAuthority(
+                connection,
+                payer,
+                account,
+                newOwner,
+                AuthorityType.AccountOwner,
+                owner.publicKey,
+                [],
+                undefined,
+                TEST_PROGRAM_ID
+            )
+        ).to.be.rejected;
+    });
+});