Remove I prefixes before Instruction types

Author: lorisleiva

.changeset/weak-boxes-stay.md

@@ -0,0 +1,9 @@
+---
+'@solana/transaction-messages': major
+'@solana/instructions': major
+'@solana/signers': major
+'@solana/compat': major
+'@solana/kit': major
+---
+
+BREAKING CHANGE: Remove the `I` prefix on the following types: `IInstruction`, `IInstructionWithAccounts`, `IInstructionWithData`, `IInstructionWithSigners`, `IAccountMeta`, `IAccountLookupMeta` and `IAccountSignerMeta`.

README.md

@@ -1168,7 +1168,7 @@ const stillNotNonceTransactionMessage = {
 };
 
 stillNotNonceTransactionMessage satisfies TransactionMessageWithDurableNonceLifetime;
-// => 'readonly IInstruction<string>[]' is not assignable to type 'readonly [AdvanceNonceAccountInstruction<string, string>, ...IInstruction<string>[]]'
+// => 'readonly Instruction<string>[]' is not assignable to type 'readonly [AdvanceNonceAccountInstruction<string, string>, ...Instruction<string>[]]'
 
 const validNonceTransactionMessage = pipe(
     createTransactionMessage({ version: 0 }),

packages/compat/README.md

@@ -47,7 +47,7 @@ const transaction = fromVersionedTransaction(legacyVersionedTransaction);
 
 ### `fromLegacyTransactionInstruction()`
 
-This can be used to convert a legacy `TransactionInstruction` object to a `IInstruction` object.
+This can be used to convert a legacy `TransactionInstruction` object to a `Instruction` object.
 
 ```ts
 import { fromLegacyTransactionInstruction } from '@solana/compat';

packages/compat/src/__tests__/instruction-test.ts

@@ -3,7 +3,7 @@ import '@solana/test-matchers/toBeFrozenObject';
 import { ImplicitArrayBuffer } from 'node:buffer';
 
 import { address } from '@solana/addresses';
-import { AccountRole, IInstruction } from '@solana/instructions';
+import { AccountRole, Instruction } from '@solana/instructions';
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 
 import { fromLegacyPublicKey } from '../address';
@@ -39,7 +39,7 @@ describe('fromLegacyTransactionInstruction', () => {
 
         const converted = fromLegacyTransactionInstruction(instruction);
 
-        expect(converted).toStrictEqual<IInstruction>({
+        expect(converted).toStrictEqual<Instruction>({
             accounts: [
                 {
                     address: address('7EqQdEULxWcraVx3mXKFjc84LhCkMGZCkRuDpvcMwJeK'),
@@ -129,7 +129,7 @@ describe('fromLegacyTransactionInstruction', () => {
 
         const converted = fromLegacyTransactionInstruction(instruction);
 
-        expect(converted).toStrictEqual<IInstruction>({
+        expect(converted).toStrictEqual<Instruction>({
             data,
             programAddress: fromLegacyPublicKey(new PublicKey(programId)),
         });
@@ -155,7 +155,7 @@ describe('fromLegacyTransactionInstruction', () => {
 
         const converted = fromLegacyTransactionInstruction(instruction);
 
-        expect(converted).toStrictEqual<IInstruction>({
+        expect(converted).toStrictEqual<Instruction>({
             accounts: [
                 {
                     address: address('7EqQdEULxWcraVx3mXKFjc84LhCkMGZCkRuDpvcMwJeK'),
@@ -189,7 +189,7 @@ describe('fromLegacyTransactionInstruction', () => {
 
         const converted = fromLegacyTransactionInstruction(instruction);
 
-        expect(converted).toStrictEqual<IInstruction>({
+        expect(converted).toStrictEqual<Instruction>({
             accounts: [
                 {
                     address: address('F7Kzv7G6p1PvHXL1xXLPTm4myKWpLjnVphCV8ABZJfgT'),
@@ -217,7 +217,7 @@ describe('fromLegacyTransactionInstruction', () => {
 
         const converted = fromLegacyTransactionInstruction(instruction);
 
-        expect(converted).toStrictEqual<IInstruction>({
+        expect(converted).toStrictEqual<Instruction>({
             accounts: [
                 {
                     address: address('F7Kzv7G6p1PvHXL1xXLPTm4myKWpLjnVphCV8ABZJfgT'),

packages/compat/src/__typetests__/instruction-typetest.ts

@@ -1,8 +1,8 @@
-import { IInstruction } from '@solana/instructions';
+import { Instruction } from '@solana/instructions';
 import { TransactionInstruction } from '@solana/web3.js';
 
 import { fromLegacyTransactionInstruction } from '../instruction';
 
 const legacyInstruction = null as unknown as TransactionInstruction;
 
-fromLegacyTransactionInstruction(legacyInstruction) satisfies IInstruction;
+fromLegacyTransactionInstruction(legacyInstruction) satisfies Instruction;

packages/compat/src/instruction.ts

@@ -1,11 +1,11 @@
-import { AccountRole, IInstruction } from '@solana/instructions';
+import { AccountRole, Instruction } from '@solana/instructions';
 import { TransactionInstruction } from '@solana/web3.js';
 
 import { fromLegacyPublicKey } from './address';
 
 /**
  * This can be used to convert a legacy [`TransactionInstruction`](https://solana-foundation.github.io/solana-web3.js/classes/TransactionInstruction.html)
- * object to an {@link IInstruction}.
+ * object to an {@link Instruction}.
  *
  * @example
  * ```ts
@@ -16,7 +16,7 @@ import { fromLegacyPublicKey } from './address';
  * const instruction = fromLegacyTransactionInstruction(legacyInstruction);
  * ```
  */
-export function fromLegacyTransactionInstruction(legacyInstruction: TransactionInstruction): IInstruction {
+export function fromLegacyTransactionInstruction(legacyInstruction: TransactionInstruction): Instruction {
     const data = legacyInstruction.data?.byteLength > 0 ? Uint8Array.from(legacyInstruction.data) : undefined;
     const accounts = legacyInstruction.keys.map(accountMeta =>
         Object.freeze({

packages/instructions/README.md

@@ -26,7 +26,7 @@ The purpose for which an account participates in a transaction is described by t
 | `AccountRole.READONLY_SIGNER` | ✅   | ❌     |
 | `AccountRole.WRITABLE_SIGNER` | ✅   | ✅     |
 
-### `IAccountMeta<TAddress>`
+### `AccountMeta<TAddress>`
 
 This type represents an account's address and metadata about its mutability and whether it must be a signer of the transaction.
 
@@ -45,7 +45,7 @@ For example, you could type the rent sysvar account like this:
 type RentSysvar = ReadonlyAccount<'SysvarRent111111111111111111111111111111111'>;
 ```
 
-### `IAccountLookupMeta<TAddress, TLookupTableAddress>`
+### `AccountLookupMeta<TAddress, TLookupTableAddress>`
 
 This type represents a lookup of the account's address in an address lookup table. It specifies which lookup table account in which to perform the lookup, the index of the desired account address in that table, and metadata about its mutability. Notably, account addresses obtained via lookups may not act as signers.
 
@@ -65,28 +65,28 @@ type RentSysvar = ReadonlyLookupAccount<
 >;
 ```
 
-### `IInstruction<TProgramAddress>`
+### `Instruction<TProgramAddress>`
 
 Use this to specify an instruction destined for a given program.
 
 ```ts
-type StakeProgramInstruction = IInstruction<'StakeConfig11111111111111111111111111111111'>;
+type StakeProgramInstruction = Instruction<'StakeConfig11111111111111111111111111111111'>;
 ```
 
-### `IInstructionWithAccounts<TAccounts>`
+### `InstructionWithAccounts<TAccounts>`
 
 Use this type to specify an instruction that loads certain accounts.
 
 ```ts
-type InstructionWithTwoAccounts = IInstructionWithAccounts<
+type InstructionWithTwoAccounts = InstructionWithAccounts<
     [
         WritableAccount, // First account
         RentSysvar, // Second account
     ]
 >;
 ```
 
-### `IInstructionWithData<TData>`
+### `InstructionWithData<TData>`
 
 Use this type to specify an instruction whose data conforms to a certain type. This is most useful when you have a branded `Uint8Array` that represents a particular instruction's data.
 
@@ -96,15 +96,15 @@ For example, here is how the `AdvanceNonce` instruction is typed.
 type AdvanceNonceAccountInstruction<
     TNonceAccountAddress extends string = string,
     TNonceAuthorityAddress extends string = string,
-> = IInstruction<'11111111111111111111111111111111'> &
-    IInstructionWithAccounts<
+> = Instruction<'11111111111111111111111111111111'> &
+    InstructionWithAccounts<
         [
             WritableAccount<TNonceAccountAddress>,
             ReadonlyAccount<'SysvarRecentB1ockHashes11111111111111111111'>,
             ReadonlySignerAccount<TNonceAuthorityAddress>,
         ]
     > &
-    IInstructionWithData<AdvanceNonceAccountInstructionData>;
+    InstructionWithData<AdvanceNonceAccountInstructionData>;
 ```
 
 ## Functions

packages/instructions/src/__tests__/instruction-test.ts

@@ -5,7 +5,7 @@ import {
     assertIsInstructionForProgram,
     assertIsInstructionWithAccounts,
     assertIsInstructionWithData,
-    IInstruction,
+    Instruction,
     isInstructionForProgram,
     isInstructionWithAccounts,
     isInstructionWithData,
@@ -16,14 +16,14 @@ const programAddress = 'address' as Address;
 
 describe('isInstructionForProgram', () => {
     it('returns true when the instruction has the given program address', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         expect(isInstructionForProgram(instruction, programAddress)).toBe(true);
     });
 
     it('returns false when the instruction does not have the given program address', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         const address = 'abc' as Address;
@@ -33,15 +33,15 @@ describe('isInstructionForProgram', () => {
 
 describe('assertIsInstructionForProgram', () => {
     it('does not throw when the instruction has the given program address', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         const assert = () => assertIsInstructionForProgram(instruction, programAddress);
         expect(assert).not.toThrow();
     });
 
     it('throws when the instruction does not have the given program address', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         const address = 'abc' as Address;
@@ -52,7 +52,7 @@ describe('assertIsInstructionForProgram', () => {
 
 describe('isInstructionWithAccounts', () => {
     it('returns true when the instruction has an array of accounts', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             accounts: [
                 {
                     address: 'abc' as Address,
@@ -65,15 +65,15 @@ describe('isInstructionWithAccounts', () => {
     });
 
     it('returns true when the instruction has an empty array of accounts', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             accounts: [],
             programAddress,
         };
         expect(isInstructionWithAccounts(instruction)).toBe(true);
     });
 
     it('returns false when the instruction does not have accounts defined', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         expect(isInstructionWithAccounts(instruction)).toBe(false);
@@ -82,7 +82,7 @@ describe('isInstructionWithAccounts', () => {
 
 describe('assertIsInstructionWithAccounts', () => {
     it('does not throw when the instruction has an array of accounts', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             accounts: [
                 {
                     address: 'abc' as Address,
@@ -96,7 +96,7 @@ describe('assertIsInstructionWithAccounts', () => {
     });
 
     it('does not throw when the instruction has an empty array of accounts', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             accounts: [],
             programAddress,
         };
@@ -105,7 +105,7 @@ describe('assertIsInstructionWithAccounts', () => {
     });
 
     it('throws when the instruction does not have accounts defined', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         const assert = () => assertIsInstructionWithAccounts(instruction);
@@ -115,23 +115,23 @@ describe('assertIsInstructionWithAccounts', () => {
 
 describe('isInstructionWithData', () => {
     it('returns true when the instruction has a non-empty data', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             data: new Uint8Array([1, 2, 3, 4]),
             programAddress,
         };
         expect(isInstructionWithData(instruction)).toBe(true);
     });
 
     it('returns true when the instruction has an empty data', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             data: new Uint8Array([]),
             programAddress,
         };
         expect(isInstructionWithData(instruction)).toBe(true);
     });
 
     it('returns false when the instruction does not have data defined', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         expect(isInstructionWithData(instruction)).toBe(false);
@@ -140,7 +140,7 @@ describe('isInstructionWithData', () => {
 
 describe('assertIsInstructionWithData', () => {
     it('does not throw when the instruction has a non-empty data', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             data: new Uint8Array([1, 2, 3, 4]),
             programAddress,
         };
@@ -149,7 +149,7 @@ describe('assertIsInstructionWithData', () => {
     });
 
     it('does not throw when the instruction has an empty data', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             data: new Uint8Array([]),
             programAddress,
         };
@@ -158,7 +158,7 @@ describe('assertIsInstructionWithData', () => {
     });
 
     it('throws when the instruction does not have data defined', () => {
-        const instruction: IInstruction = {
+        const instruction: Instruction = {
             programAddress,
         };
         const assert = () => assertIsInstructionWithData(instruction);