@floorlaunchpad/sdk-solana 0.0.0-stage → 0.1.1

package/src/generated/client/floor_holders/instructions/rotateClaimsTable.ts

@@ -0,0 +1,141 @@
+/**
+ * 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 { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { findClaimsAltAuthorityPda, findClaimsRegistryPda } from '../pdas/index.js';
+import { FLOOR_HOLDERS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const ROTATE_CLAIMS_TABLE_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([78, 254, 119, 206, 38, 21, 63, 222]);
+
+export function getRotateClaimsTableDiscriminatorBytes(): ReadonlyUint8Array { return fixEncoderSize(getBytesEncoder(), 8).encode(ROTATE_CLAIMS_TABLE_DISCRIMINATOR); }
+
+export type RotateClaimsTableInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountClaimsRegistry extends string | AccountMeta<string> = string, TAccountClaimsAltAuthority extends string | AccountMeta<string> = string, TAccountNewTable extends string | AccountMeta<string> = string, TAccountAltProgram extends string | AccountMeta<string> = "AddressLookupTab1e1111111111111111111111111", TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TAccountEventAuthority extends string | AccountMeta<string> = string, TAccountProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountClaimsRegistry extends string ? WritableAccount<TAccountClaimsRegistry> : TAccountClaimsRegistry, TAccountClaimsAltAuthority extends string ? ReadonlyAccount<TAccountClaimsAltAuthority> : TAccountClaimsAltAuthority, TAccountNewTable extends string ? WritableAccount<TAccountNewTable> : TAccountNewTable, TAccountAltProgram extends string ? ReadonlyAccount<TAccountAltProgram> : TAccountAltProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, TAccountEventAuthority extends string ? ReadonlyAccount<TAccountEventAuthority> : TAccountEventAuthority, TAccountProgram extends string ? ReadonlyAccount<TAccountProgram> : TAccountProgram, ...TRemainingAccounts]>;
+
+export type RotateClaimsTableInstructionData = { discriminator: ReadonlyUint8Array; recentSlot: bigint;  };
+
+export type RotateClaimsTableInstructionDataArgs = { recentSlot: number | bigint;  };
+
+export function getRotateClaimsTableInstructionDataEncoder(): FixedSizeEncoder<RotateClaimsTableInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['recentSlot', getU64Encoder()]]), (value) => ({ ...value, discriminator: ROTATE_CLAIMS_TABLE_DISCRIMINATOR }));
+}
+
+export function getRotateClaimsTableInstructionDataDecoder(): FixedSizeDecoder<RotateClaimsTableInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['recentSlot', getU64Decoder()]]);
+}
+
+export function getRotateClaimsTableInstructionDataCodec(): FixedSizeCodec<RotateClaimsTableInstructionDataArgs, RotateClaimsTableInstructionData> {
+    return combineCodec(getRotateClaimsTableInstructionDataEncoder(), getRotateClaimsTableInstructionDataDecoder());
+}
+
+export type RotateClaimsTableAsyncInput<TAccountPayer extends string = string, TAccountClaimsRegistry extends string = string, TAccountClaimsAltAuthority extends string = string, TAccountNewTable extends string = string, TAccountAltProgram extends string = string, TAccountSystemProgram extends string = string, TAccountEventAuthority extends string = string, TAccountProgram extends string = string> =  {
+  payer: TransactionSigner<TAccountPayer>;
+claimsRegistry?: Address<TAccountClaimsRegistry>;
+claimsAltAuthority?: Address<TAccountClaimsAltAuthority>;
+newTable: Address<TAccountNewTable>;
+altProgram?: Address<TAccountAltProgram>;
+systemProgram?: Address<TAccountSystemProgram>;
+eventAuthority: Address<TAccountEventAuthority>;
+program: Address<TAccountProgram>;
+recentSlot: RotateClaimsTableInstructionDataArgs["recentSlot"];
+}
+
+export async function getRotateClaimsTableInstructionAsync<TAccountPayer extends string, TAccountClaimsRegistry extends string, TAccountClaimsAltAuthority extends string, TAccountNewTable extends string, TAccountAltProgram extends string, TAccountSystemProgram extends string, TAccountEventAuthority extends string, TAccountProgram extends string, TProgramAddress extends Address = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS>(input: RotateClaimsTableAsyncInput<TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>, config?: { programAddress?: TProgramAddress } ): Promise<RotateClaimsTableInstruction<TProgramAddress, TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>> {
+  // Program address.
+const programAddress = config?.programAddress ?? FLOOR_HOLDERS_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { payer: { value: input.payer ?? null, isWritable: true }, claimsRegistry: { value: input.claimsRegistry ?? null, isWritable: true }, claimsAltAuthority: { value: input.claimsAltAuthority ?? null, isWritable: false }, newTable: { value: input.newTable ?? null, isWritable: true }, altProgram: { value: input.altProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false }, eventAuthority: { value: input.eventAuthority ?? null, isWritable: false }, program: { value: input.program ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.claimsRegistry.value) {
+accounts.claimsRegistry.value = await findClaimsRegistryPda({ programAddress });
+}
+if (!accounts.claimsAltAuthority.value) {
+accounts.claimsAltAuthority.value = await findClaimsAltAuthorityPda({ programAddress });
+}
+if (!accounts.altProgram.value) {
+accounts.altProgram.value = 'AddressLookupTab1e1111111111111111111111111' as Address<'AddressLookupTab1e1111111111111111111111111'>;
+}
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("payer", accounts.payer), getAccountMeta("claimsRegistry", accounts.claimsRegistry), getAccountMeta("claimsAltAuthority", accounts.claimsAltAuthority), getAccountMeta("newTable", accounts.newTable), getAccountMeta("altProgram", accounts.altProgram), getAccountMeta("systemProgram", accounts.systemProgram), getAccountMeta("eventAuthority", accounts.eventAuthority), getAccountMeta("program", accounts.program)], data: getRotateClaimsTableInstructionDataEncoder().encode(args as RotateClaimsTableInstructionDataArgs), programAddress } as RotateClaimsTableInstruction<TProgramAddress, TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>);
+}
+
+export type RotateClaimsTableInput<TAccountPayer extends string = string, TAccountClaimsRegistry extends string = string, TAccountClaimsAltAuthority extends string = string, TAccountNewTable extends string = string, TAccountAltProgram extends string = string, TAccountSystemProgram extends string = string, TAccountEventAuthority extends string = string, TAccountProgram extends string = string> =  {
+  payer: TransactionSigner<TAccountPayer>;
+claimsRegistry: Address<TAccountClaimsRegistry>;
+claimsAltAuthority: Address<TAccountClaimsAltAuthority>;
+newTable: Address<TAccountNewTable>;
+altProgram?: Address<TAccountAltProgram>;
+systemProgram?: Address<TAccountSystemProgram>;
+eventAuthority: Address<TAccountEventAuthority>;
+program: Address<TAccountProgram>;
+recentSlot: RotateClaimsTableInstructionDataArgs["recentSlot"];
+}
+
+export function getRotateClaimsTableInstruction<TAccountPayer extends string, TAccountClaimsRegistry extends string, TAccountClaimsAltAuthority extends string, TAccountNewTable extends string, TAccountAltProgram extends string, TAccountSystemProgram extends string, TAccountEventAuthority extends string, TAccountProgram extends string, TProgramAddress extends Address = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS>(input: RotateClaimsTableInput<TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>, config?: { programAddress?: TProgramAddress } ): RotateClaimsTableInstruction<TProgramAddress, TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram> {
+  // Program address.
+const programAddress = config?.programAddress ?? FLOOR_HOLDERS_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { payer: { value: input.payer ?? null, isWritable: true }, claimsRegistry: { value: input.claimsRegistry ?? null, isWritable: true }, claimsAltAuthority: { value: input.claimsAltAuthority ?? null, isWritable: false }, newTable: { value: input.newTable ?? null, isWritable: true }, altProgram: { value: input.altProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false }, eventAuthority: { value: input.eventAuthority ?? null, isWritable: false }, program: { value: input.program ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.altProgram.value) {
+accounts.altProgram.value = 'AddressLookupTab1e1111111111111111111111111' as Address<'AddressLookupTab1e1111111111111111111111111'>;
+}
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("payer", accounts.payer), getAccountMeta("claimsRegistry", accounts.claimsRegistry), getAccountMeta("claimsAltAuthority", accounts.claimsAltAuthority), getAccountMeta("newTable", accounts.newTable), getAccountMeta("altProgram", accounts.altProgram), getAccountMeta("systemProgram", accounts.systemProgram), getAccountMeta("eventAuthority", accounts.eventAuthority), getAccountMeta("program", accounts.program)], data: getRotateClaimsTableInstructionDataEncoder().encode(args as RotateClaimsTableInstructionDataArgs), programAddress } as RotateClaimsTableInstruction<TProgramAddress, TAccountPayer, TAccountClaimsRegistry, TAccountClaimsAltAuthority, TAccountNewTable, TAccountAltProgram, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>);
+}
+
+export type ParsedRotateClaimsTableInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+payer: TAccountMetas[0];
+claimsRegistry: TAccountMetas[1];
+claimsAltAuthority: TAccountMetas[2];
+newTable: TAccountMetas[3];
+altProgram: TAccountMetas[4];
+systemProgram: TAccountMetas[5];
+eventAuthority: TAccountMetas[6];
+program: TAccountMetas[7];
+};
+data: RotateClaimsTableInstructionData; };
+
+export function parseRotateClaimsTableInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedRotateClaimsTableInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 8) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 8 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { payer: getNextAccount(), claimsRegistry: getNextAccount(), claimsAltAuthority: getNextAccount(), newTable: getNextAccount(), altProgram: getNextAccount(), systemProgram: getNextAccount(), eventAuthority: getNextAccount(), program: getNextAccount() }, data: getRotateClaimsTableInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/client/floor_holders/instructions/sync.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { FLOOR_HOLDERS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const SYNC_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([4, 219, 40, 164, 21, 157, 189, 88]);
+
+export function getSyncDiscriminatorBytes(): ReadonlyUint8Array { return fixEncoderSize(getBytesEncoder(), 8).encode(SYNC_DISCRIMINATOR); }
+
+export type SyncInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountMint extends string | AccountMeta<string> = string, TAccountHolderBook extends string | AccountMeta<string> = string, TAccountFloorPool extends string | AccountMeta<string> = string, TAccountTokenAccount extends string | AccountMeta<string> = string, TAccountRecord extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountMint extends string ? ReadonlyAccount<TAccountMint> : TAccountMint, TAccountHolderBook extends string ? WritableAccount<TAccountHolderBook> : TAccountHolderBook, TAccountFloorPool extends string ? ReadonlyAccount<TAccountFloorPool> : TAccountFloorPool, TAccountTokenAccount extends string ? ReadonlyAccount<TAccountTokenAccount> : TAccountTokenAccount, TAccountRecord extends string ? WritableAccount<TAccountRecord> : TAccountRecord, ...TRemainingAccounts]>;
+
+export type SyncInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type SyncInstructionDataArgs = {  };
+
+export function getSyncInstructionDataEncoder(): FixedSizeEncoder<SyncInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: SYNC_DISCRIMINATOR }));
+}
+
+export function getSyncInstructionDataDecoder(): FixedSizeDecoder<SyncInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getSyncInstructionDataCodec(): FixedSizeCodec<SyncInstructionDataArgs, SyncInstructionData> {
+    return combineCodec(getSyncInstructionDataEncoder(), getSyncInstructionDataDecoder());
+}
+
+export type SyncInput<TAccountMint extends string = string, TAccountHolderBook extends string = string, TAccountFloorPool extends string = string, TAccountTokenAccount extends string = string, TAccountRecord extends string = string> =  {
+  mint: Address<TAccountMint>;
+holderBook: Address<TAccountHolderBook>;
+floorPool: Address<TAccountFloorPool>;
+tokenAccount: Address<TAccountTokenAccount>;
+record: Address<TAccountRecord>;
+}
+
+export function getSyncInstruction<TAccountMint extends string, TAccountHolderBook extends string, TAccountFloorPool extends string, TAccountTokenAccount extends string, TAccountRecord extends string, TProgramAddress extends Address = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS>(input: SyncInput<TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord>, config?: { programAddress?: TProgramAddress } ): SyncInstruction<TProgramAddress, TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord> {
+  // Program address.
+const programAddress = config?.programAddress ?? FLOOR_HOLDERS_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { mint: { value: input.mint ?? null, isWritable: false }, holderBook: { value: input.holderBook ?? null, isWritable: true }, floorPool: { value: input.floorPool ?? null, isWritable: false }, tokenAccount: { value: input.tokenAccount ?? null, isWritable: false }, record: { value: input.record ?? null, isWritable: true } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("mint", accounts.mint), getAccountMeta("holderBook", accounts.holderBook), getAccountMeta("floorPool", accounts.floorPool), getAccountMeta("tokenAccount", accounts.tokenAccount), getAccountMeta("record", accounts.record)], data: getSyncInstructionDataEncoder().encode({}), programAddress } as SyncInstruction<TProgramAddress, TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord>);
+}
+
+export type ParsedSyncInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+mint: TAccountMetas[0];
+holderBook: TAccountMetas[1];
+floorPool: TAccountMetas[2];
+tokenAccount: TAccountMetas[3];
+record: TAccountMetas[4];
+};
+data: SyncInstructionData; };
+
+export function parseSyncInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSyncInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 5) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 5 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { mint: getNextAccount(), holderBook: getNextAccount(), floorPool: getNextAccount(), tokenAccount: getNextAccount(), record: getNextAccount() }, data: getSyncInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/client/floor_holders/instructions/touch.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { combineCodec, fixDecoderSize, fixEncoderSize, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { FLOOR_HOLDERS_PROGRAM_ADDRESS } from '../programs/index.js';
+
+export const TOUCH_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([80, 157, 106, 220, 181, 72, 101, 81]);
+
+export function getTouchDiscriminatorBytes(): ReadonlyUint8Array { return fixEncoderSize(getBytesEncoder(), 8).encode(TOUCH_DISCRIMINATOR); }
+
+export type TouchInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMint extends string | AccountMeta<string> = string, TAccountHolderBook extends string | AccountMeta<string> = string, TAccountFloorPool extends string | AccountMeta<string> = string, TAccountTokenAccount extends string | AccountMeta<string> = string, TAccountRecord extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TAccountEventAuthority extends string | AccountMeta<string> = string, TAccountProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner, TAccountMint extends string ? ReadonlyAccount<TAccountMint> : TAccountMint, TAccountHolderBook extends string ? WritableAccount<TAccountHolderBook> : TAccountHolderBook, TAccountFloorPool extends string ? ReadonlyAccount<TAccountFloorPool> : TAccountFloorPool, TAccountTokenAccount extends string ? ReadonlyAccount<TAccountTokenAccount> : TAccountTokenAccount, TAccountRecord extends string ? WritableAccount<TAccountRecord> : TAccountRecord, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, TAccountEventAuthority extends string ? ReadonlyAccount<TAccountEventAuthority> : TAccountEventAuthority, TAccountProgram extends string ? ReadonlyAccount<TAccountProgram> : TAccountProgram, ...TRemainingAccounts]>;
+
+export type TouchInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type TouchInstructionDataArgs = {  };
+
+export function getTouchInstructionDataEncoder(): FixedSizeEncoder<TouchInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: TOUCH_DISCRIMINATOR }));
+}
+
+export function getTouchInstructionDataDecoder(): FixedSizeDecoder<TouchInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getTouchInstructionDataCodec(): FixedSizeCodec<TouchInstructionDataArgs, TouchInstructionData> {
+    return combineCodec(getTouchInstructionDataEncoder(), getTouchInstructionDataDecoder());
+}
+
+export type TouchInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountMint extends string = string, TAccountHolderBook extends string = string, TAccountFloorPool extends string = string, TAccountTokenAccount extends string = string, TAccountRecord extends string = string, TAccountSystemProgram extends string = string, TAccountEventAuthority extends string = string, TAccountProgram extends string = string> =  {
+  payer: TransactionSigner<TAccountPayer>;
+owner: Address<TAccountOwner>;
+mint: Address<TAccountMint>;
+holderBook: Address<TAccountHolderBook>;
+floorPool: Address<TAccountFloorPool>;
+tokenAccount: Address<TAccountTokenAccount>;
+record: Address<TAccountRecord>;
+systemProgram?: Address<TAccountSystemProgram>;
+eventAuthority: Address<TAccountEventAuthority>;
+program: Address<TAccountProgram>;
+}
+
+export function getTouchInstruction<TAccountPayer extends string, TAccountOwner extends string, TAccountMint extends string, TAccountHolderBook extends string, TAccountFloorPool extends string, TAccountTokenAccount extends string, TAccountRecord extends string, TAccountSystemProgram extends string, TAccountEventAuthority extends string, TAccountProgram extends string, TProgramAddress extends Address = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS>(input: TouchInput<TAccountPayer, TAccountOwner, TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>, config?: { programAddress?: TProgramAddress } ): TouchInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram> {
+  // Program address.
+const programAddress = config?.programAddress ?? FLOOR_HOLDERS_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { payer: { value: input.payer ?? null, isWritable: true }, owner: { value: input.owner ?? null, isWritable: false }, mint: { value: input.mint ?? null, isWritable: false }, holderBook: { value: input.holderBook ?? null, isWritable: true }, floorPool: { value: input.floorPool ?? null, isWritable: false }, tokenAccount: { value: input.tokenAccount ?? null, isWritable: false }, record: { value: input.record ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false }, eventAuthority: { value: input.eventAuthority ?? null, isWritable: false }, program: { value: input.program ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("payer", accounts.payer), getAccountMeta("owner", accounts.owner), getAccountMeta("mint", accounts.mint), getAccountMeta("holderBook", accounts.holderBook), getAccountMeta("floorPool", accounts.floorPool), getAccountMeta("tokenAccount", accounts.tokenAccount), getAccountMeta("record", accounts.record), getAccountMeta("systemProgram", accounts.systemProgram), getAccountMeta("eventAuthority", accounts.eventAuthority), getAccountMeta("program", accounts.program)], data: getTouchInstructionDataEncoder().encode({}), programAddress } as TouchInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMint, TAccountHolderBook, TAccountFloorPool, TAccountTokenAccount, TAccountRecord, TAccountSystemProgram, TAccountEventAuthority, TAccountProgram>);
+}
+
+export type ParsedTouchInstruction<TProgram extends string = typeof FLOOR_HOLDERS_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+payer: TAccountMetas[0];
+owner: TAccountMetas[1];
+mint: TAccountMetas[2];
+holderBook: TAccountMetas[3];
+floorPool: TAccountMetas[4];
+tokenAccount: TAccountMetas[5];
+record: TAccountMetas[6];
+systemProgram: TAccountMetas[7];
+eventAuthority: TAccountMetas[8];
+program: TAccountMetas[9];
+};
+data: TouchInstructionData; };
+
+export function parseTouchInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedTouchInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 10) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 10 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { payer: getNextAccount(), owner: getNextAccount(), mint: getNextAccount(), holderBook: getNextAccount(), floorPool: getNextAccount(), tokenAccount: getNextAccount(), record: getNextAccount(), systemProgram: getNextAccount(), eventAuthority: getNextAccount(), program: getNextAccount() }, data: getTouchInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/client/floor_holders/pdas/claimsAltAuthority.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { getBytesEncoder, getProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
+
+export async function findClaimsAltAuthorityPda(config: { programAddress?: Address | undefined } = {}): Promise<ProgramDerivedAddress> {
+  const { programAddress = '2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te' as Address<'2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te'> } = config;
+  return await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([99, 108, 97, 105, 109, 115, 95, 97, 108, 116, 95, 97, 117, 116, 104, 111, 114, 105, 116, 121]))]});
+}

package/src/generated/client/floor_holders/pdas/claimsRegistry.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { getBytesEncoder, getProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
+
+export async function findClaimsRegistryPda(config: { programAddress?: Address | undefined } = {}): Promise<ProgramDerivedAddress> {
+  const { programAddress = '2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te' as Address<'2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te'> } = config;
+  return await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([99, 108, 97, 105, 109, 115, 95, 114, 101, 103, 105, 115, 116, 114, 121]))]});
+}

package/src/generated/client/floor_holders/pdas/holdersAuthority.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { getBytesEncoder, getProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
+
+export async function findHoldersAuthorityPda(config: { programAddress?: Address | undefined } = {}): Promise<ProgramDerivedAddress> {
+  const { programAddress = '2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te' as Address<'2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te'> } = config;
+  return await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([104, 111, 108, 100, 101, 114, 115, 95, 97, 117, 116, 104, 111, 114, 105, 116, 121]))]});
+}

package/src/generated/client/floor_holders/pdas/index.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+
+export * from './claimsAltAuthority.js';
+export * from './claimsRegistry.js';
+export * from './holdersAuthority.js';

package/src/generated/client/floor_holders/programs/floorHolders.ts

@@ -0,0 +1,103 @@
+/**
+ * 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 { assertIsInstructionWithAccounts, containsBytes, extendClient, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type ExtendedClient, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { addSelfPlanAndSendFunctions, type SelfPlanAndSendFunctions } from '@solana/kit/program-client-core';
+import { getAuthorizeClaimInstructionAsync, getClaimInstructionAsync, getCloseRecordInstruction, getExecuteInstruction, getInitializeClaimsRegistryInstructionAsync, getInitLaunchInstructionAsync, getOpenRecordInstruction, getRotateClaimsTableInstructionAsync, getSyncInstruction, getTouchInstruction, parseAuthorizeClaimInstruction, parseClaimInstruction, parseCloseRecordInstruction, parseExecuteInstruction, parseInitializeClaimsRegistryInstruction, parseInitLaunchInstruction, parseOpenRecordInstruction, parseRotateClaimsTableInstruction, parseSyncInstruction, parseTouchInstruction, type AuthorizeClaimAsyncInput, type ClaimAsyncInput, type CloseRecordInput, type ExecuteInput, type InitializeClaimsRegistryAsyncInput, type InitLaunchAsyncInput, type OpenRecordInput, type ParsedAuthorizeClaimInstruction, type ParsedClaimInstruction, type ParsedCloseRecordInstruction, type ParsedExecuteInstruction, type ParsedInitializeClaimsRegistryInstruction, type ParsedInitLaunchInstruction, type ParsedOpenRecordInstruction, type ParsedRotateClaimsTableInstruction, type ParsedSyncInstruction, type ParsedTouchInstruction, type RotateClaimsTableAsyncInput, type SyncInput, type TouchInput } from '../instructions/index.js';
+import { findClaimsAltAuthorityPda, findClaimsRegistryPda, findHoldersAuthorityPda } from '../pdas/index.js';
+
+export const FLOOR_HOLDERS_PROGRAM_ADDRESS = '2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te' as Address<'2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te'>;
+
+export enum FloorHoldersEvent { ClaimsTableExtended, ClaimsTableRotated, HolderClaimed, LaunchHooked, RecordClosed, RecordOpened }
+
+export function identifyFloorHoldersEvent(event: { data: ReadonlyUint8Array } | ReadonlyUint8Array): FloorHoldersEvent {
+    const data = 'data' in event ? event.data : event;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([48, 152, 152, 51, 196, 185, 114, 124])), 0)) { return FloorHoldersEvent.ClaimsTableExtended; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([250, 66, 36, 218, 69, 255, 21, 252])), 0)) { return FloorHoldersEvent.ClaimsTableRotated; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([135, 192, 236, 75, 181, 166, 203, 87])), 0)) { return FloorHoldersEvent.HolderClaimed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([43, 10, 196, 165, 174, 85, 247, 241])), 0)) { return FloorHoldersEvent.LaunchHooked; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([99, 152, 89, 8, 23, 79, 153, 2])), 0)) { return FloorHoldersEvent.RecordClosed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([99, 226, 191, 99, 102, 248, 208, 176])), 0)) { return FloorHoldersEvent.RecordOpened; }
+    throw new Error('The provided event could not be identified as a floorHolders event.');
+}
+
+export enum FloorHoldersInstruction { AuthorizeClaim, Claim, CloseRecord, Execute, InitLaunch, InitializeClaimsRegistry, OpenRecord, RotateClaimsTable, Sync, Touch }
+
+export function identifyFloorHoldersInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): FloorHoldersInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([7, 168, 241, 195, 41, 85, 16, 181])), 0)) { return FloorHoldersInstruction.AuthorizeClaim; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([62, 198, 214, 193, 213, 159, 108, 210])), 0)) { return FloorHoldersInstruction.Claim; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([111, 192, 122, 188, 38, 234, 242, 249])), 0)) { return FloorHoldersInstruction.CloseRecord; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([105, 37, 101, 197, 75, 251, 102, 26])), 0)) { return FloorHoldersInstruction.Execute; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([75, 162, 31, 198, 192, 109, 36, 169])), 0)) { return FloorHoldersInstruction.InitLaunch; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([100, 149, 120, 121, 174, 196, 31, 31])), 0)) { return FloorHoldersInstruction.InitializeClaimsRegistry; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([9, 245, 244, 116, 110, 216, 54, 158])), 0)) { return FloorHoldersInstruction.OpenRecord; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([78, 254, 119, 206, 38, 21, 63, 222])), 0)) { return FloorHoldersInstruction.RotateClaimsTable; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([4, 219, 40, 164, 21, 157, 189, 88])), 0)) { return FloorHoldersInstruction.Sync; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([80, 157, 106, 220, 181, 72, 101, 81])), 0)) { return FloorHoldersInstruction.Touch; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "floorHolders" });
+}
+
+export type ParsedFloorHoldersInstruction<TProgram extends string = '2EUkJXSwCdRAuhesw2D9FXyGfbi6Kw2yZDyQUnCwc7te'> =
+| { instructionType: FloorHoldersInstruction.AuthorizeClaim } & ParsedAuthorizeClaimInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.Claim } & ParsedClaimInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.CloseRecord } & ParsedCloseRecordInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.Execute } & ParsedExecuteInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.InitLaunch } & ParsedInitLaunchInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.InitializeClaimsRegistry } & ParsedInitializeClaimsRegistryInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.OpenRecord } & ParsedOpenRecordInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.RotateClaimsTable } & ParsedRotateClaimsTableInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.Sync } & ParsedSyncInstruction<TProgram>
+| { instructionType: FloorHoldersInstruction.Touch } & ParsedTouchInstruction<TProgram>
+
+
+        export function parseFloorHoldersInstruction<TProgram extends string>(
+            instruction: Instruction<TProgram> 
+                & InstructionWithData<ReadonlyUint8Array>
+        ): ParsedFloorHoldersInstruction<TProgram> {
+            const instructionType = identifyFloorHoldersInstruction(instruction);
+            switch (instructionType) {
+                case FloorHoldersInstruction.AuthorizeClaim: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.AuthorizeClaim, ...parseAuthorizeClaimInstruction(instruction) }; }
+case FloorHoldersInstruction.Claim: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.Claim, ...parseClaimInstruction(instruction) }; }
+case FloorHoldersInstruction.CloseRecord: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.CloseRecord, ...parseCloseRecordInstruction(instruction) }; }
+case FloorHoldersInstruction.Execute: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.Execute, ...parseExecuteInstruction(instruction) }; }
+case FloorHoldersInstruction.InitLaunch: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.InitLaunch, ...parseInitLaunchInstruction(instruction) }; }
+case FloorHoldersInstruction.InitializeClaimsRegistry: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.InitializeClaimsRegistry, ...parseInitializeClaimsRegistryInstruction(instruction) }; }
+case FloorHoldersInstruction.OpenRecord: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.OpenRecord, ...parseOpenRecordInstruction(instruction) }; }
+case FloorHoldersInstruction.RotateClaimsTable: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.RotateClaimsTable, ...parseRotateClaimsTableInstruction(instruction) }; }
+case FloorHoldersInstruction.Sync: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.Sync, ...parseSyncInstruction(instruction) }; }
+case FloorHoldersInstruction.Touch: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHoldersInstruction.Touch, ...parseTouchInstruction(instruction) }; }
+                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: "floorHolders" });
+            }
+        }
+
+export type FloorHoldersPlugin = { instructions: FloorHoldersPluginInstructions; pdas: FloorHoldersPluginPdas; identifyInstruction: typeof identifyFloorHoldersInstruction; parseInstruction: typeof parseFloorHoldersInstruction; }
+
+export type FloorHoldersPluginInstructions = { authorizeClaim: (input: AuthorizeClaimAsyncInput) => ReturnType<typeof getAuthorizeClaimInstructionAsync> & SelfPlanAndSendFunctions; claim: (input: ClaimAsyncInput) => ReturnType<typeof getClaimInstructionAsync> & SelfPlanAndSendFunctions; closeRecord: (input: CloseRecordInput) => ReturnType<typeof getCloseRecordInstruction> & SelfPlanAndSendFunctions; execute: (input: ExecuteInput) => ReturnType<typeof getExecuteInstruction> & SelfPlanAndSendFunctions; initLaunch: (input: MakeOptional<InitLaunchAsyncInput, "payer">) => ReturnType<typeof getInitLaunchInstructionAsync> & SelfPlanAndSendFunctions; initializeClaimsRegistry: (input: MakeOptional<InitializeClaimsRegistryAsyncInput, "payer">) => ReturnType<typeof getInitializeClaimsRegistryInstructionAsync> & SelfPlanAndSendFunctions; openRecord: (input: MakeOptional<OpenRecordInput, "payer">) => ReturnType<typeof getOpenRecordInstruction> & SelfPlanAndSendFunctions; rotateClaimsTable: (input: MakeOptional<RotateClaimsTableAsyncInput, "payer">) => ReturnType<typeof getRotateClaimsTableInstructionAsync> & SelfPlanAndSendFunctions; sync: (input: SyncInput) => ReturnType<typeof getSyncInstruction> & SelfPlanAndSendFunctions; touch: (input: MakeOptional<TouchInput, "payer">) => ReturnType<typeof getTouchInstruction> & SelfPlanAndSendFunctions; }
+
+export type FloorHoldersPluginPdas = { holdersAuthority: typeof findHoldersAuthorityPda; claimsRegistry: typeof findClaimsRegistryPda; claimsAltAuthority: typeof findClaimsAltAuthorityPda; }
+
+export type FloorHoldersPluginRequirements = ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending
+
+export function floorHoldersProgram() {
+    return <T extends FloorHoldersPluginRequirements>(client: T): ExtendedClient<T, { floorHolders: FloorHoldersPlugin }> => {
+        return extendClient(client, { floorHolders: <FloorHoldersPlugin>{ instructions: { authorizeClaim: input => addSelfPlanAndSendFunctions(client, getAuthorizeClaimInstructionAsync(input)), claim: input => addSelfPlanAndSendFunctions(client, getClaimInstructionAsync(input)), closeRecord: input => addSelfPlanAndSendFunctions(client, getCloseRecordInstruction(input)), execute: input => addSelfPlanAndSendFunctions(client, getExecuteInstruction(input)), initLaunch: input => addSelfPlanAndSendFunctions(client, getInitLaunchInstructionAsync({ ...input, payer: input.payer ?? client.payer })), initializeClaimsRegistry: input => addSelfPlanAndSendFunctions(client, getInitializeClaimsRegistryInstructionAsync({ ...input, payer: input.payer ?? client.payer })), openRecord: input => addSelfPlanAndSendFunctions(client, getOpenRecordInstruction({ ...input, payer: input.payer ?? client.payer })), rotateClaimsTable: input => addSelfPlanAndSendFunctions(client, getRotateClaimsTableInstructionAsync({ ...input, payer: input.payer ?? client.payer })), sync: input => addSelfPlanAndSendFunctions(client, getSyncInstruction(input)), touch: input => addSelfPlanAndSendFunctions(client, getTouchInstruction({ ...input, payer: input.payer ?? client.payer })) }, pdas: { holdersAuthority: findHoldersAuthorityPda, claimsRegistry: findClaimsRegistryPda, claimsAltAuthority: findClaimsAltAuthorityPda }, identifyInstruction: identifyFloorHoldersInstruction, parseInstruction: parseFloorHoldersInstruction } });
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/client/floor_holders/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+
+export * from './floorHolders.js';

package/src/generated/client/floor_hook/accounts/floorPlatformPool.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder, type Account, type Address, type EncodedAccount, type FetchAccountConfig, type FetchAccountsConfig, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+
+export const FLOOR_PLATFORM_POOL_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([167, 208, 168, 33, 137, 35, 5, 31]);
+
+export function getFloorPlatformPoolDiscriminatorBytes(): ReadonlyUint8Array { return fixEncoderSize(getBytesEncoder(), 8).encode(FLOOR_PLATFORM_POOL_DISCRIMINATOR); }
+
+export type FloorPlatformPool = { discriminator: ReadonlyUint8Array; version: number; bump: number; pad0: ReadonlyUint8Array; floorPool: Address; ammPool: Address; baseMint: Address; quoteMint: Address; received: bigint; credits: bigint; designatedSlot: bigint; reserved: ReadonlyUint8Array;  };
+
+export type FloorPlatformPoolArgs = { version: number; bump: number; pad0: ReadonlyUint8Array; floorPool: Address; ammPool: Address; baseMint: Address; quoteMint: Address; received: number | bigint; credits: number | bigint; designatedSlot: number | bigint; reserved: ReadonlyUint8Array;  };
+
+/** Gets the encoder for {@link FloorPlatformPoolArgs} account data. */
+export function getFloorPlatformPoolEncoder(): FixedSizeEncoder<FloorPlatformPoolArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['version', getU8Encoder()], ['bump', getU8Encoder()], ['pad0', fixEncoderSize(getBytesEncoder(), 6)], ['floorPool', getAddressEncoder()], ['ammPool', getAddressEncoder()], ['baseMint', getAddressEncoder()], ['quoteMint', getAddressEncoder()], ['received', getU64Encoder()], ['credits', getU64Encoder()], ['designatedSlot', getU64Encoder()], ['reserved', fixEncoderSize(getBytesEncoder(), 64)]]), (value) => ({ ...value, discriminator: FLOOR_PLATFORM_POOL_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link FloorPlatformPool} account data. */
+export function getFloorPlatformPoolDecoder(): FixedSizeDecoder<FloorPlatformPool> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['version', getU8Decoder()], ['bump', getU8Decoder()], ['pad0', fixDecoderSize(getBytesDecoder(), 6)], ['floorPool', getAddressDecoder()], ['ammPool', getAddressDecoder()], ['baseMint', getAddressDecoder()], ['quoteMint', getAddressDecoder()], ['received', getU64Decoder()], ['credits', getU64Decoder()], ['designatedSlot', getU64Decoder()], ['reserved', fixDecoderSize(getBytesDecoder(), 64)]]);
+}
+
+/** Gets the codec for {@link FloorPlatformPool} account data. */
+export function getFloorPlatformPoolCodec(): FixedSizeCodec<FloorPlatformPoolArgs, FloorPlatformPool> {
+    return combineCodec(getFloorPlatformPoolEncoder(), getFloorPlatformPoolDecoder());
+}
+
+export function decodeFloorPlatformPool<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<FloorPlatformPool, TAddress>;
+export function decodeFloorPlatformPool<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<FloorPlatformPool, TAddress>;
+export function decodeFloorPlatformPool<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<FloorPlatformPool, TAddress> | MaybeAccount<FloorPlatformPool, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getFloorPlatformPoolDecoder());
+}
+
+export async function fetchFloorPlatformPool<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<FloorPlatformPool, TAddress>> {
+  const maybeAccount = await fetchMaybeFloorPlatformPool(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeFloorPlatformPool<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<FloorPlatformPool, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeFloorPlatformPool(maybeAccount);
+}
+
+export async function fetchAllFloorPlatformPool(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<FloorPlatformPool>[]> {
+  const maybeAccounts = await fetchAllMaybeFloorPlatformPool(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeFloorPlatformPool(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<FloorPlatformPool>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeFloorPlatformPool(maybeAccount));
+}
+
+export function getFloorPlatformPoolSize(): number {
+  return 232;
+}