diff --git a/clients/js/src/generated/instructions/batch.ts b/clients/js/src/generated/instructions/batch.ts
new file mode 100644
index 00000000..3aee12b0
--- /dev/null
+++ b/clients/js/src/generated/instructions/batch.ts
@@ -0,0 +1,138 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    AccountRole,
+    addDecoderSizePrefix,
+    addEncoderSizePrefix,
+    combineCodec,
+    getArrayDecoder,
+    getArrayEncoder,
+    getBytesDecoder,
+    getBytesEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    getU8Decoder,
+    getU8Encoder,
+    transformEncoder,
+    type AccountMeta,
+    type Address,
+    type Codec,
+    type Decoder,
+    type Encoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+} from '@solana/kit';
+import { TOKEN_PROGRAM_ADDRESS } from '../programs';
+
+export const BATCH_DISCRIMINATOR = 255;
+
+export function getBatchDiscriminatorBytes() {
+    return getU8Encoder().encode(BATCH_DISCRIMINATOR);
+}
+
+export type BatchInstruction<
+    TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<TRemainingAccounts>;
+
+export type BatchInstructionData = {
+    discriminator: number;
+    /** Instruction data for batch instructions. */
+    data: Array<{ numberOfAccounts: number; instructionData: ReadonlyUint8Array }>;
+};
+
+export type BatchInstructionDataArgs = {
+    /** Instruction data for batch instructions. */
+    data: Array<{ numberOfAccounts: number; instructionData: ReadonlyUint8Array }>;
+};
+
+export function getBatchInstructionDataEncoder(): Encoder<BatchInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            [
+                'data',
+                getArrayEncoder(
+                    getStructEncoder([
+                        ['numberOfAccounts', getU8Encoder()],
+                        ['instructionData', addEncoderSizePrefix(getBytesEncoder(), getU8Encoder())],
+                    ]),
+                    { size: 'remainder' },
+                ),
+            ],
+        ]),
+        value => ({ ...value, discriminator: BATCH_DISCRIMINATOR }),
+    );
+}
+
+export function getBatchInstructionDataDecoder(): Decoder<BatchInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        [
+            'data',
+            getArrayDecoder(
+                getStructDecoder([
+                    ['numberOfAccounts', getU8Decoder()],
+                    ['instructionData', addDecoderSizePrefix(getBytesDecoder(), getU8Decoder())],
+                ]),
+                { size: 'remainder' },
+            ),
+        ],
+    ]);
+}
+
+export function getBatchInstructionDataCodec(): Codec<BatchInstructionDataArgs, BatchInstructionData> {
+    return combineCodec(getBatchInstructionDataEncoder(), getBatchInstructionDataDecoder());
+}
+
+export type BatchInput = {
+    data: BatchInstructionDataArgs['data'];
+    accounts?: Array<TransactionSigner>;
+};
+
+export function getBatchInstruction<TProgramAddress extends Address = typeof TOKEN_PROGRAM_ADDRESS>(
+    input: BatchInput,
+    config?: { programAddress?: TProgramAddress },
+): BatchInstruction<TProgramAddress> {
+    // Program address.
+    const programAddress = config?.programAddress ?? TOKEN_PROGRAM_ADDRESS;
+
+    // Original args.
+    const args = { ...input };
+
+    // Remaining accounts.
+    const remainingAccounts: AccountMeta[] = (args.accounts ?? []).map(signer => ({
+        address: signer.address,
+        role: AccountRole.READONLY_SIGNER,
+        signer,
+    }));
+
+    return Object.freeze({
+        accounts: remainingAccounts,
+        data: getBatchInstructionDataEncoder().encode(args as BatchInstructionDataArgs),
+        programAddress,
+    } as BatchInstruction<TProgramAddress>);
+}
+
+export type ParsedBatchInstruction<TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS> = {
+    programAddress: Address<TProgram>;
+    data: BatchInstructionData;
+};
+
+export function parseBatchInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedBatchInstruction<TProgram> {
+    return {
+        programAddress: instruction.programAddress,
+        data: getBatchInstructionDataDecoder().decode(instruction.data),
+    };
+}
diff --git a/clients/js/src/generated/instructions/index.ts b/clients/js/src/generated/instructions/index.ts
index a9731e09..2626709b 100644
--- a/clients/js/src/generated/instructions/index.ts
+++ b/clients/js/src/generated/instructions/index.ts
@@ -9,6 +9,7 @@
 export * from './amountToUiAmount';
 export * from './approve';
 export * from './approveChecked';
+export * from './batch';
 export * from './burn';
 export * from './burnChecked';
 export * from './closeAccount';
@@ -34,3 +35,5 @@ export * from './thawAccount';
 export * from './transfer';
 export * from './transferChecked';
 export * from './uiAmountToAmount';
+export * from './unwrapLamports';
+export * from './withdrawExcessLamports';
diff --git a/clients/js/src/generated/instructions/syncNative.ts b/clients/js/src/generated/instructions/syncNative.ts
index 118fc893..bb0a40ad 100644
--- a/clients/js/src/generated/instructions/syncNative.ts
+++ b/clients/js/src/generated/instructions/syncNative.ts
@@ -23,6 +23,7 @@ import {
     type Instruction,
     type InstructionWithAccounts,
     type InstructionWithData,
+    type ReadonlyAccount,
     type ReadonlyUint8Array,
     type WritableAccount,
 } from '@solana/kit';
@@ -38,11 +39,18 @@ export function getSyncNativeDiscriminatorBytes() {
 export type SyncNativeInstruction<
     TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
     TAccountAccount extends string | AccountMeta<string> = string,
+    TAccountRent extends string | AccountMeta<string> | undefined = undefined,
     TRemainingAccounts extends readonly AccountMeta<string>[] = [],
 > = Instruction<TProgram> &
     InstructionWithData<ReadonlyUint8Array> &
     InstructionWithAccounts<
-        [TAccountAccount extends string ? WritableAccount<TAccountAccount> : TAccountAccount, ...TRemainingAccounts]
+        [
+            TAccountAccount extends string ? WritableAccount<TAccountAccount> : TAccountAccount,
+            ...(TAccountRent extends undefined
+                ? []
+                : [TAccountRent extends string ? ReadonlyAccount<TAccountRent> : TAccountRent]),
+            ...TRemainingAccounts,
+        ]
     >;
 
 export type SyncNativeInstructionData = { discriminator: number };
@@ -67,31 +75,45 @@ export function getSyncNativeInstructionDataCodec(): FixedSizeCodec<
     return combineCodec(getSyncNativeInstructionDataEncoder(), getSyncNativeInstructionDataDecoder());
 }
 
-export type SyncNativeInput<TAccountAccount extends string = string> = {
+export type SyncNativeInput<TAccountAccount extends string = string, TAccountRent extends string = string> = {
     /** The native token account to sync with its underlying lamports. */
     account: Address<TAccountAccount>;
+    /** Rent sysvar. */
+    rent?: Address<TAccountRent>;
 };
 
 export function getSyncNativeInstruction<
     TAccountAccount extends string,
+    TAccountRent extends string,
     TProgramAddress extends Address = typeof TOKEN_PROGRAM_ADDRESS,
 >(
-    input: SyncNativeInput<TAccountAccount>,
+    input: SyncNativeInput<TAccountAccount, TAccountRent>,
     config?: { programAddress?: TProgramAddress },
-): SyncNativeInstruction<TProgramAddress, TAccountAccount> {
+): SyncNativeInstruction<TProgramAddress, TAccountAccount, TAccountRent> {
     // Program address.
     const programAddress = config?.programAddress ?? TOKEN_PROGRAM_ADDRESS;
 
     // Original accounts.
-    const originalAccounts = { account: { value: input.account ?? null, isWritable: true } };
+    const originalAccounts = {
+        account: { value: input.account ?? null, isWritable: true },
+        rent: { value: input.rent ?? null, isWritable: false },
+    };
     const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
 
-    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    // Resolve default values.
+    if (!accounts.rent.value) {
+        accounts.rent.value =
+            'SysvarRent111111111111111111111111111111111' as Address<'SysvarRent111111111111111111111111111111111'>;
+    }
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
     return Object.freeze({
-        accounts: [getAccountMeta('account', accounts.account)],
+        accounts: [getAccountMeta('account', accounts.account), getAccountMeta('rent', accounts.rent)].filter(
+            <T>(x: T | undefined): x is T => x !== undefined,
+        ),
         data: getSyncNativeInstructionDataEncoder().encode({}),
         programAddress,
-    } as SyncNativeInstruction<TProgramAddress, TAccountAccount>);
+    } as SyncNativeInstruction<TProgramAddress, TAccountAccount, TAccountRent>);
 }
 
 export type ParsedSyncNativeInstruction<
@@ -102,6 +124,8 @@ export type ParsedSyncNativeInstruction<
     accounts: {
         /** The native token account to sync with its underlying lamports. */
         account: TAccountMetas[0];
+        /** Rent sysvar. */
+        rent?: TAccountMetas[1] | undefined;
     };
     data: SyncNativeInstructionData;
 };
@@ -123,9 +147,15 @@ export function parseSyncNativeInstruction<TProgram extends string, TAccountMeta
         accountIndex += 1;
         return accountMeta;
     };
+    let optionalAccountsRemaining = instruction.accounts.length - 1;
+    const getNextOptionalAccount = () => {
+        if (optionalAccountsRemaining === 0) return undefined;
+        optionalAccountsRemaining -= 1;
+        return getNextAccount();
+    };
     return {
         programAddress: instruction.programAddress,
-        accounts: { account: getNextAccount() },
+        accounts: { account: getNextAccount(), rent: getNextOptionalAccount() },
         data: getSyncNativeInstructionDataDecoder().decode(instruction.data),
     };
 }
diff --git a/clients/js/src/generated/instructions/unwrapLamports.ts b/clients/js/src/generated/instructions/unwrapLamports.ts
new file mode 100644
index 00000000..fe9a32cc
--- /dev/null
+++ b/clients/js/src/generated/instructions/unwrapLamports.ts
@@ -0,0 +1,218 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    AccountRole,
+    combineCodec,
+    getOptionDecoder,
+    getOptionEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    getU64Decoder,
+    getU64Encoder,
+    getU8Decoder,
+    getU8Encoder,
+    none,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type Codec,
+    type Decoder,
+    type Encoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type Option,
+    type OptionOrNullable,
+    type ReadonlyAccount,
+    type ReadonlySignerAccount,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+    type WritableAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { TOKEN_PROGRAM_ADDRESS } from '../programs';
+
+export const UNWRAP_LAMPORTS_DISCRIMINATOR = 45;
+
+export function getUnwrapLamportsDiscriminatorBytes() {
+    return getU8Encoder().encode(UNWRAP_LAMPORTS_DISCRIMINATOR);
+}
+
+export type UnwrapLamportsInstruction<
+    TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
+    TAccountSource extends string | AccountMeta<string> = string,
+    TAccountDestination extends string | AccountMeta<string> = string,
+    TAccountAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountSource extends string ? WritableAccount<TAccountSource> : TAccountSource,
+            TAccountDestination extends string ? WritableAccount<TAccountDestination> : TAccountDestination,
+            TAccountAuthority extends string ? ReadonlyAccount<TAccountAuthority> : TAccountAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type UnwrapLamportsInstructionData = {
+    discriminator: number;
+    /**
+     * Optional amount of lamports to transfer.
+     * If not provided, the instruction will unwrap all lamports in excess of rent exemption.
+     */
+    amount: Option<bigint>;
+};
+
+export type UnwrapLamportsInstructionDataArgs = {
+    /**
+     * Optional amount of lamports to transfer.
+     * If not provided, the instruction will unwrap all lamports in excess of rent exemption.
+     */
+    amount?: OptionOrNullable<number | bigint>;
+};
+
+export function getUnwrapLamportsInstructionDataEncoder(): Encoder<UnwrapLamportsInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU8Encoder()],
+            ['amount', getOptionEncoder(getU64Encoder())],
+        ]),
+        value => ({ ...value, discriminator: UNWRAP_LAMPORTS_DISCRIMINATOR, amount: value.amount ?? none() }),
+    );
+}
+
+export function getUnwrapLamportsInstructionDataDecoder(): Decoder<UnwrapLamportsInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU8Decoder()],
+        ['amount', getOptionDecoder(getU64Decoder())],
+    ]);
+}
+
+export function getUnwrapLamportsInstructionDataCodec(): Codec<
+    UnwrapLamportsInstructionDataArgs,
+    UnwrapLamportsInstructionData
+> {
+    return combineCodec(getUnwrapLamportsInstructionDataEncoder(), getUnwrapLamportsInstructionDataDecoder());
+}
+
+export type UnwrapLamportsInput<
+    TAccountSource extends string = string,
+    TAccountDestination extends string = string,
+    TAccountAuthority extends string = string,
+> = {
+    /** The source account. */
+    source: Address<TAccountSource>;
+    /** The destination account. */
+    destination: Address<TAccountDestination>;
+    /** The source account owner or its multisignature account. */
+    authority: Address<TAccountAuthority> | TransactionSigner<TAccountAuthority>;
+    amount?: UnwrapLamportsInstructionDataArgs['amount'];
+    multiSigners?: Array<TransactionSigner>;
+};
+
+export function getUnwrapLamportsInstruction<
+    TAccountSource extends string,
+    TAccountDestination extends string,
+    TAccountAuthority extends string,
+    TProgramAddress extends Address = typeof TOKEN_PROGRAM_ADDRESS,
+>(
+    input: UnwrapLamportsInput<TAccountSource, TAccountDestination, TAccountAuthority>,
+    config?: { programAddress?: TProgramAddress },
+): UnwrapLamportsInstruction<
+    TProgramAddress,
+    TAccountSource,
+    TAccountDestination,
+    (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+        ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority>
+        : TAccountAuthority
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? TOKEN_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        source: { value: input.source ?? null, isWritable: true },
+        destination: { value: input.destination ?? null, isWritable: true },
+        authority: { value: input.authority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Remaining accounts.
+    const remainingAccounts: AccountMeta[] = (args.multiSigners ?? []).map(signer => ({
+        address: signer.address,
+        role: AccountRole.READONLY_SIGNER,
+        signer,
+    }));
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('source', accounts.source),
+            getAccountMeta('destination', accounts.destination),
+            getAccountMeta('authority', accounts.authority),
+            ...remainingAccounts,
+        ],
+        data: getUnwrapLamportsInstructionDataEncoder().encode(args as UnwrapLamportsInstructionDataArgs),
+        programAddress,
+    } as UnwrapLamportsInstruction<
+        TProgramAddress,
+        TAccountSource,
+        TAccountDestination,
+        (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+            ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority>
+            : TAccountAuthority
+    >);
+}
+
+export type ParsedUnwrapLamportsInstruction<
+    TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** The source account. */
+        source: TAccountMetas[0];
+        /** The destination account. */
+        destination: TAccountMetas[1];
+        /** The source account owner or its multisignature account. */
+        authority: TAccountMetas[2];
+    };
+    data: UnwrapLamportsInstructionData;
+};
+
+export function parseUnwrapLamportsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedUnwrapLamportsInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 3) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 3,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { source: getNextAccount(), destination: getNextAccount(), authority: getNextAccount() },
+        data: getUnwrapLamportsInstructionDataDecoder().decode(instruction.data),
+    };
+}
diff --git a/clients/js/src/generated/instructions/withdrawExcessLamports.ts b/clients/js/src/generated/instructions/withdrawExcessLamports.ts
new file mode 100644
index 00000000..02467803
--- /dev/null
+++ b/clients/js/src/generated/instructions/withdrawExcessLamports.ts
@@ -0,0 +1,197 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    AccountRole,
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU8Decoder,
+    getU8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyAccount,
+    type ReadonlySignerAccount,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+    type WritableAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { TOKEN_PROGRAM_ADDRESS } from '../programs';
+
+export const WITHDRAW_EXCESS_LAMPORTS_DISCRIMINATOR = 38;
+
+export function getWithdrawExcessLamportsDiscriminatorBytes() {
+    return getU8Encoder().encode(WITHDRAW_EXCESS_LAMPORTS_DISCRIMINATOR);
+}
+
+export type WithdrawExcessLamportsInstruction<
+    TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
+    TAccountSource extends string | AccountMeta<string> = string,
+    TAccountDestination extends string | AccountMeta<string> = string,
+    TAccountAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountSource extends string ? WritableAccount<TAccountSource> : TAccountSource,
+            TAccountDestination extends string ? WritableAccount<TAccountDestination> : TAccountDestination,
+            TAccountAuthority extends string ? ReadonlyAccount<TAccountAuthority> : TAccountAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type WithdrawExcessLamportsInstructionData = { discriminator: number };
+
+export type WithdrawExcessLamportsInstructionDataArgs = {};
+
+export function getWithdrawExcessLamportsInstructionDataEncoder(): FixedSizeEncoder<WithdrawExcessLamportsInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', getU8Encoder()]]), value => ({
+        ...value,
+        discriminator: WITHDRAW_EXCESS_LAMPORTS_DISCRIMINATOR,
+    }));
+}
+
+export function getWithdrawExcessLamportsInstructionDataDecoder(): FixedSizeDecoder<WithdrawExcessLamportsInstructionData> {
+    return getStructDecoder([['discriminator', getU8Decoder()]]);
+}
+
+export function getWithdrawExcessLamportsInstructionDataCodec(): FixedSizeCodec<
+    WithdrawExcessLamportsInstructionDataArgs,
+    WithdrawExcessLamportsInstructionData
+> {
+    return combineCodec(
+        getWithdrawExcessLamportsInstructionDataEncoder(),
+        getWithdrawExcessLamportsInstructionDataDecoder(),
+    );
+}
+
+export type WithdrawExcessLamportsInput<
+    TAccountSource extends string = string,
+    TAccountDestination extends string = string,
+    TAccountAuthority extends string = string,
+> = {
+    /** The source account. */
+    source: Address<TAccountSource>;
+    /** The destination account. */
+    destination: Address<TAccountDestination>;
+    /** The source account owner or its multisignature account. */
+    authority: Address<TAccountAuthority> | TransactionSigner<TAccountAuthority>;
+    multiSigners?: Array<TransactionSigner>;
+};
+
+export function getWithdrawExcessLamportsInstruction<
+    TAccountSource extends string,
+    TAccountDestination extends string,
+    TAccountAuthority extends string,
+    TProgramAddress extends Address = typeof TOKEN_PROGRAM_ADDRESS,
+>(
+    input: WithdrawExcessLamportsInput<TAccountSource, TAccountDestination, TAccountAuthority>,
+    config?: { programAddress?: TProgramAddress },
+): WithdrawExcessLamportsInstruction<
+    TProgramAddress,
+    TAccountSource,
+    TAccountDestination,
+    (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+        ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority>
+        : TAccountAuthority
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? TOKEN_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        source: { value: input.source ?? null, isWritable: true },
+        destination: { value: input.destination ?? null, isWritable: true },
+        authority: { value: input.authority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Remaining accounts.
+    const remainingAccounts: AccountMeta[] = (args.multiSigners ?? []).map(signer => ({
+        address: signer.address,
+        role: AccountRole.READONLY_SIGNER,
+        signer,
+    }));
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('source', accounts.source),
+            getAccountMeta('destination', accounts.destination),
+            getAccountMeta('authority', accounts.authority),
+            ...remainingAccounts,
+        ],
+        data: getWithdrawExcessLamportsInstructionDataEncoder().encode({}),
+        programAddress,
+    } as WithdrawExcessLamportsInstruction<
+        TProgramAddress,
+        TAccountSource,
+        TAccountDestination,
+        (typeof input)['authority'] extends TransactionSigner<TAccountAuthority>
+            ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority>
+            : TAccountAuthority
+    >);
+}
+
+export type ParsedWithdrawExcessLamportsInstruction<
+    TProgram extends string = typeof TOKEN_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** The source account. */
+        source: TAccountMetas[0];
+        /** The destination account. */
+        destination: TAccountMetas[1];
+        /** The source account owner or its multisignature account. */
+        authority: TAccountMetas[2];
+    };
+    data: WithdrawExcessLamportsInstructionData;
+};
+
+export function parseWithdrawExcessLamportsInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedWithdrawExcessLamportsInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 3) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 3,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { source: getNextAccount(), destination: getNextAccount(), authority: getNextAccount() },
+        data: getWithdrawExcessLamportsInstructionDataDecoder().decode(instruction.data),
+    };
+}
diff --git a/clients/js/src/generated/programs/token.ts b/clients/js/src/generated/programs/token.ts
index f2094234..58beff35 100644
--- a/clients/js/src/generated/programs/token.ts
+++ b/clients/js/src/generated/programs/token.ts
@@ -45,6 +45,7 @@ import {
     getAmountToUiAmountInstruction,
     getApproveCheckedInstruction,
     getApproveInstruction,
+    getBatchInstruction,
     getBurnCheckedInstruction,
     getBurnInstruction,
     getCloseAccountInstruction,
@@ -67,9 +68,12 @@ import {
     getTransferCheckedInstruction,
     getTransferInstruction,
     getUiAmountToAmountInstruction,
+    getUnwrapLamportsInstruction,
+    getWithdrawExcessLamportsInstruction,
     parseAmountToUiAmountInstruction,
     parseApproveCheckedInstruction,
     parseApproveInstruction,
+    parseBatchInstruction,
     parseBurnCheckedInstruction,
     parseBurnInstruction,
     parseCloseAccountInstruction,
@@ -92,9 +96,12 @@ import {
     parseTransferCheckedInstruction,
     parseTransferInstruction,
     parseUiAmountToAmountInstruction,
+    parseUnwrapLamportsInstruction,
+    parseWithdrawExcessLamportsInstruction,
     type AmountToUiAmountInput,
     type ApproveCheckedInput,
     type ApproveInput,
+    type BatchInput,
     type BurnCheckedInput,
     type BurnInput,
     type CloseAccountInput,
@@ -113,6 +120,7 @@ import {
     type ParsedAmountToUiAmountInstruction,
     type ParsedApproveCheckedInstruction,
     type ParsedApproveInstruction,
+    type ParsedBatchInstruction,
     type ParsedBurnCheckedInstruction,
     type ParsedBurnInstruction,
     type ParsedCloseAccountInstruction,
@@ -135,6 +143,8 @@ import {
     type ParsedTransferCheckedInstruction,
     type ParsedTransferInstruction,
     type ParsedUiAmountToAmountInstruction,
+    type ParsedUnwrapLamportsInstruction,
+    type ParsedWithdrawExcessLamportsInstruction,
     type RevokeInput,
     type SetAuthorityInput,
     type SyncNativeInput,
@@ -142,6 +152,8 @@ import {
     type TransferCheckedInput,
     type TransferInput,
     type UiAmountToAmountInput,
+    type UnwrapLamportsInput,
+    type WithdrawExcessLamportsInput,
 } from '../instructions';
 
 export const TOKEN_PROGRAM_ADDRESS =
@@ -196,6 +208,9 @@ export enum TokenInstruction {
     InitializeImmutableOwner,
     AmountToUiAmount,
     UiAmountToAmount,
+    WithdrawExcessLamports,
+    UnwrapLamports,
+    Batch,
 }
 
 export function identifyTokenInstruction(
@@ -277,6 +292,15 @@ export function identifyTokenInstruction(
     if (containsBytes(data, getU8Encoder().encode(24), 0)) {
         return TokenInstruction.UiAmountToAmount;
     }
+    if (containsBytes(data, getU8Encoder().encode(38), 0)) {
+        return TokenInstruction.WithdrawExcessLamports;
+    }
+    if (containsBytes(data, getU8Encoder().encode(45), 0)) {
+        return TokenInstruction.UnwrapLamports;
+    }
+    if (containsBytes(data, getU8Encoder().encode(255), 0)) {
+        return TokenInstruction.Batch;
+    }
     throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
         instructionData: data,
         programName: 'token',
@@ -310,7 +334,10 @@ export type ParsedTokenInstruction<TProgram extends string = 'TokenkegQfeZyiNwAJ
           instructionType: TokenInstruction.InitializeImmutableOwner;
       } & ParsedInitializeImmutableOwnerInstruction<TProgram>)
     | ({ instructionType: TokenInstruction.AmountToUiAmount } & ParsedAmountToUiAmountInstruction<TProgram>)
-    | ({ instructionType: TokenInstruction.UiAmountToAmount } & ParsedUiAmountToAmountInstruction<TProgram>);
+    | ({ instructionType: TokenInstruction.UiAmountToAmount } & ParsedUiAmountToAmountInstruction<TProgram>)
+    | ({ instructionType: TokenInstruction.WithdrawExcessLamports } & ParsedWithdrawExcessLamportsInstruction<TProgram>)
+    | ({ instructionType: TokenInstruction.UnwrapLamports } & ParsedUnwrapLamportsInstruction<TProgram>)
+    | ({ instructionType: TokenInstruction.Batch } & ParsedBatchInstruction<TProgram>);
 
 export function parseTokenInstruction<TProgram extends string>(
     instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
@@ -450,6 +477,20 @@ export function parseTokenInstruction<TProgram extends string>(
                 ...parseUiAmountToAmountInstruction(instruction),
             };
         }
+        case TokenInstruction.WithdrawExcessLamports: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: TokenInstruction.WithdrawExcessLamports,
+                ...parseWithdrawExcessLamportsInstruction(instruction),
+            };
+        }
+        case TokenInstruction.UnwrapLamports: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: TokenInstruction.UnwrapLamports, ...parseUnwrapLamportsInstruction(instruction) };
+        }
+        case TokenInstruction.Batch: {
+            return { instructionType: TokenInstruction.Batch, ...parseBatchInstruction(instruction) };
+        }
         default:
             throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
                 instructionType: instructionType as string,
@@ -526,6 +567,13 @@ export type TokenPluginInstructions = {
     uiAmountToAmount: (
         input: UiAmountToAmountInput,
     ) => ReturnType<typeof getUiAmountToAmountInstruction> & SelfPlanAndSendFunctions;
+    withdrawExcessLamports: (
+        input: WithdrawExcessLamportsInput,
+    ) => ReturnType<typeof getWithdrawExcessLamportsInstruction> & SelfPlanAndSendFunctions;
+    unwrapLamports: (
+        input: UnwrapLamportsInput,
+    ) => ReturnType<typeof getUnwrapLamportsInstruction> & SelfPlanAndSendFunctions;
+    batch: (input: BatchInput) => ReturnType<typeof getBatchInstruction> & SelfPlanAndSendFunctions;
 };
 
 export type TokenPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> &
@@ -577,6 +625,10 @@ export function tokenProgram() {
                         addSelfPlanAndSendFunctions(client, getAmountToUiAmountInstruction(input)),
                     uiAmountToAmount: input =>
                         addSelfPlanAndSendFunctions(client, getUiAmountToAmountInstruction(input)),
+                    withdrawExcessLamports: input =>
+                        addSelfPlanAndSendFunctions(client, getWithdrawExcessLamportsInstruction(input)),
+                    unwrapLamports: input => addSelfPlanAndSendFunctions(client, getUnwrapLamportsInstruction(input)),
+                    batch: input => addSelfPlanAndSendFunctions(client, getBatchInstruction(input)),
                 },
             },
         };
diff --git a/program/idl.json b/program/idl.json
index 83c87941..3b477d64 100644
--- a/program/idl.json
+++ b/program/idl.json
@@ -1639,6 +1639,18 @@
             "docs": [
               "The native token account to sync with its underlying lamports."
             ]
+          },
+          {
+            "kind": "instructionAccountNode",
+            "name": "rent",
+            "isWritable": false,
+            "isSigner": false,
+            "isOptional": true,
+            "docs": ["Rent sysvar."],
+            "defaultValue": {
+              "kind": "publicKeyValueNode",
+              "publicKey": "SysvarRent111111111111111111111111111111111"
+            }
           }
         ],
         "arguments": [
@@ -1670,7 +1682,7 @@
           "`system_instruction::transfer` to move lamports to a wrapped token",
           "account, and needs to have its token `amount` field updated."
         ],
-        "optionalAccountStrategy": "programId"
+        "optionalAccountStrategy": "omitted"
       },
       {
         "kind": "instructionNode",
@@ -2058,6 +2070,242 @@
           "the return data as a little-endian `u64`."
         ],
         "optionalAccountStrategy": "programId"
+      },
+      {
+        "kind": "instructionNode",
+        "accounts": [
+          {
+            "kind": "instructionAccountNode",
+            "name": "source",
+            "isWritable": true,
+            "isSigner": false,
+            "isOptional": false,
+            "docs": ["The source account."]
+          },
+          {
+            "kind": "instructionAccountNode",
+            "name": "destination",
+            "isWritable": true,
+            "isSigner": false,
+            "isOptional": false,
+            "docs": ["The destination account."]
+          },
+          {
+            "kind": "instructionAccountNode",
+            "name": "authority",
+            "isWritable": false,
+            "isSigner": "either",
+            "isOptional": false,
+            "docs": ["The source account owner or its multisignature account."]
+          }
+        ],
+        "arguments": [
+          {
+            "kind": "instructionArgumentNode",
+            "name": "discriminator",
+            "type": {
+              "kind": "numberTypeNode",
+              "format": "u8",
+              "endian": "le"
+            },
+            "docs": [],
+            "defaultValue": { "kind": "numberValueNode", "number": 38 },
+            "defaultValueStrategy": "omitted"
+          }
+        ],
+        "discriminators": [
+          {
+            "kind": "fieldDiscriminatorNode",
+            "name": "discriminator",
+            "offset": 0
+          }
+        ],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "multiSigners"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
+        "name": "withdrawExcessLamports",
+        "docs": [
+          "Rescue SOL sent to any TokenProgram-owned account",
+          "by sending them to any other account, leaving behind only",
+          "lamports for rent exemption."
+        ],
+        "optionalAccountStrategy": "programId"
+      },
+      {
+        "kind": "instructionNode",
+        "accounts": [
+          {
+            "kind": "instructionAccountNode",
+            "name": "source",
+            "isWritable": true,
+            "isSigner": false,
+            "isOptional": false,
+            "docs": ["The source account."]
+          },
+          {
+            "kind": "instructionAccountNode",
+            "name": "destination",
+            "isWritable": true,
+            "isSigner": false,
+            "isOptional": false,
+            "docs": ["The destination account."]
+          },
+          {
+            "kind": "instructionAccountNode",
+            "name": "authority",
+            "isWritable": false,
+            "isSigner": "either",
+            "isOptional": false,
+            "docs": ["The source account owner or its multisignature account."]
+          }
+        ],
+        "arguments": [
+          {
+            "kind": "instructionArgumentNode",
+            "name": "discriminator",
+            "type": {
+              "kind": "numberTypeNode",
+              "format": "u8",
+              "endian": "le"
+            },
+            "docs": [],
+            "defaultValue": { "kind": "numberValueNode", "number": 45 },
+            "defaultValueStrategy": "omitted"
+          },
+          {
+            "kind": "instructionArgumentNode",
+            "name": "amount",
+            "type": {
+              "kind": "optionTypeNode",
+              "item": {
+                "kind": "numberTypeNode",
+                "format": "u64",
+                "endian": "le"
+              },
+              "prefix": {
+                "kind": "numberTypeNode",
+                "format": "u8",
+                "endian": "le"
+              },
+              "fixed": false
+            },
+            "defaultValue": {
+              "kind": "noneValueNode"
+            },
+            "docs": [
+              "Optional amount of lamports to transfer.",
+              "If not provided, the instruction will unwrap all lamports in excess of rent exemption."
+            ]
+          }
+        ],
+        "discriminators": [
+          {
+            "kind": "fieldDiscriminatorNode",
+            "name": "discriminator",
+            "offset": 0
+          }
+        ],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "multiSigners"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
+        "name": "UnwrapLamports",
+        "docs": [
+          "Transfer lamports from a native SOL account to a destination account."
+        ],
+        "optionalAccountStrategy": "programId"
+      },
+      {
+        "kind": "instructionNode",
+        "accounts": [],
+        "arguments": [
+          {
+            "kind": "instructionArgumentNode",
+            "name": "discriminator",
+            "type": {
+              "kind": "numberTypeNode",
+              "format": "u8",
+              "endian": "le"
+            },
+            "docs": [],
+            "defaultValue": { "kind": "numberValueNode", "number": 255 },
+            "defaultValueStrategy": "omitted"
+          },
+          {
+            "kind": "instructionArgumentNode",
+            "name": "data",
+            "type": {
+              "kind": "arrayTypeNode",
+              "item": {
+                "kind": "structTypeNode",
+                "fields": [
+                  {
+                    "kind": "structFieldTypeNode",
+                    "name": "numberOfAccounts",
+                    "type": {
+                      "kind": "numberTypeNode",
+                      "format": "u8",
+                      "endian": "le"
+                    }
+                  },
+                  {
+                    "kind": "structFieldTypeNode",
+                    "name": "instructionData",
+                    "type": {
+                      "kind": "sizePrefixTypeNode", 
+                      "prefix": {
+                        "kind": "numberTypeNode",
+                        "format": "u8",
+                        "endian": "le"
+                      },
+                      "type": { "kind": "bytesTypeNode" } }
+                  }
+                ]
+              },
+              "count": { "kind": "remainderCountNode" }
+            },
+            "docs": ["Instruction data for batch instructions."]
+          }
+        ],
+        "discriminators": [
+          {
+            "kind": "fieldDiscriminatorNode",
+            "name": "discriminator",
+            "offset": 0
+          }
+        ],
+        "remainingAccounts": [
+          {
+            "kind": "instructionRemainingAccountsNode",
+            "value": {
+              "kind": "argumentValueNode",
+              "name": "accounts"
+            },
+            "isOptional": true,
+            "isSigner": true
+          }
+        ],
+        "name": "Batch",
+        "docs": [
+          "Executes a batch of instructions. The instructions to be executed are",
+          "specified in sequence on the instruction data."
+        ],
+        "optionalAccountStrategy": "programId"
       }
     ],
     "definedTypes": [