@floorlaunchpad/sdk-solana 0.0.0-stage → 0.1.1

package/src/generated/client/floor_hook/programs/floorHook.ts

@@ -0,0 +1,305 @@
+/**
+ * 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_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type ExtendedClient, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/kit/program-client-core';
+import { getFloorPlatformPoolCodec, getFloorPoolCodec, getHookConfigCodec, getPlatformTreasuryCodec, getQuotePolicyCodec, type FloorPlatformPool, type FloorPlatformPoolArgs, type FloorPool, type FloorPoolArgs, type HookConfig, type HookConfigArgs, type PlatformTreasury, type PlatformTreasuryArgs, type QuotePolicy, type QuotePolicyArgs } from '../accounts/index.js';
+import { getAcceptHookGovernanceInstructionAsync, getAcceptTeamTreasuryGovernanceInstructionAsync, getAcceptTreasuryGovernanceInstructionAsync, getAfterActionsInstruction, getAfterSwapInstruction, getBeforeInitializeInstruction, getBeforeSwapInstruction, getClaimCreatorFeesInstructionAsync, getClaimReferralFeesInstructionAsync, getClaimTraderReferralInstructionAsync, getClearTeamBuyBooksInstructionAsync, getCreditFloorPoolInstructionAsync, getCreditTraderBucketInstructionAsync, getDesignateFloorPoolInstructionAsync, getDonateInventoryInstruction, getInitializeHookConfigInstructionAsync, getInitializeTeamTreasuryInstructionAsync, getListQuoteInstructionAsync, getObserveQuoteInstruction, getOpenTraderBucketInstruction, getOpenTraderRefVaultInstructionAsync, getPayHolderAuthorizedInstructionAsync, getPayHolderInstructionAsync, getPreparePositionsInstructionAsync, getRatchetInstructionAsync, getReclaimStairArrayInstructionAsync, getRegisterPoolInstructionAsync, getResolveRecipientInstructionAsync, getResolveStairPayeeInstructionAsync, getRetireQuoteInstructionAsync, getSeedFloorInstruction, getSeedInventoryInstructionAsync, getSeedLiquidityInstructionAsync, getSetAllowAllQuotesInstructionAsync, getSetGenesisStairInstructionAsync, getSetHookGovernanceInstructionAsync, getSetQuoteEconomicsInstructionAsync, getSetTeamTreasuryGovernanceInstructionAsync, getSetTreasuryGovernanceInstructionAsync, getSweepPlatformCutInstructionAsync, getSweepStairFeesInstructionAsync, getSweepStairPayeeInstructionAsync, getSweepTraderReferralInstructionAsync, getTwapTickInstruction, getWithdrawPlatformInstructionAsync, getWithdrawStairTokensInstructionAsync, getWithdrawTeamInstructionAsync, parseAcceptHookGovernanceInstruction, parseAcceptTeamTreasuryGovernanceInstruction, parseAcceptTreasuryGovernanceInstruction, parseAfterActionsInstruction, parseAfterSwapInstruction, parseBeforeInitializeInstruction, parseBeforeSwapInstruction, parseClaimCreatorFeesInstruction, parseClaimReferralFeesInstruction, parseClaimTraderReferralInstruction, parseClearTeamBuyBooksInstruction, parseCreditFloorPoolInstruction, parseCreditTraderBucketInstruction, parseDesignateFloorPoolInstruction, parseDonateInventoryInstruction, parseInitializeHookConfigInstruction, parseInitializeTeamTreasuryInstruction, parseListQuoteInstruction, parseObserveQuoteInstruction, parseOpenTraderBucketInstruction, parseOpenTraderRefVaultInstruction, parsePayHolderAuthorizedInstruction, parsePayHolderInstruction, parsePreparePositionsInstruction, parseRatchetInstruction, parseReclaimStairArrayInstruction, parseRegisterPoolInstruction, parseResolveRecipientInstruction, parseResolveStairPayeeInstruction, parseRetireQuoteInstruction, parseSeedFloorInstruction, parseSeedInventoryInstruction, parseSeedLiquidityInstruction, parseSetAllowAllQuotesInstruction, parseSetGenesisStairInstruction, parseSetHookGovernanceInstruction, parseSetQuoteEconomicsInstruction, parseSetTeamTreasuryGovernanceInstruction, parseSetTreasuryGovernanceInstruction, parseSweepPlatformCutInstruction, parseSweepStairFeesInstruction, parseSweepStairPayeeInstruction, parseSweepTraderReferralInstruction, parseTwapTickInstruction, parseWithdrawPlatformInstruction, parseWithdrawStairTokensInstruction, parseWithdrawTeamInstruction, type AcceptHookGovernanceAsyncInput, type AcceptTeamTreasuryGovernanceAsyncInput, type AcceptTreasuryGovernanceAsyncInput, type AfterActionsInput, type AfterSwapInput, type BeforeInitializeInput, type BeforeSwapInput, type ClaimCreatorFeesAsyncInput, type ClaimReferralFeesAsyncInput, type ClaimTraderReferralAsyncInput, type ClearTeamBuyBooksAsyncInput, type CreditFloorPoolAsyncInput, type CreditTraderBucketAsyncInput, type DesignateFloorPoolAsyncInput, type DonateInventoryInput, type InitializeHookConfigAsyncInput, type InitializeTeamTreasuryAsyncInput, type ListQuoteAsyncInput, type ObserveQuoteInput, type OpenTraderBucketInput, type OpenTraderRefVaultAsyncInput, type ParsedAcceptHookGovernanceInstruction, type ParsedAcceptTeamTreasuryGovernanceInstruction, type ParsedAcceptTreasuryGovernanceInstruction, type ParsedAfterActionsInstruction, type ParsedAfterSwapInstruction, type ParsedBeforeInitializeInstruction, type ParsedBeforeSwapInstruction, type ParsedClaimCreatorFeesInstruction, type ParsedClaimReferralFeesInstruction, type ParsedClaimTraderReferralInstruction, type ParsedClearTeamBuyBooksInstruction, type ParsedCreditFloorPoolInstruction, type ParsedCreditTraderBucketInstruction, type ParsedDesignateFloorPoolInstruction, type ParsedDonateInventoryInstruction, type ParsedInitializeHookConfigInstruction, type ParsedInitializeTeamTreasuryInstruction, type ParsedListQuoteInstruction, type ParsedObserveQuoteInstruction, type ParsedOpenTraderBucketInstruction, type ParsedOpenTraderRefVaultInstruction, type ParsedPayHolderAuthorizedInstruction, type ParsedPayHolderInstruction, type ParsedPreparePositionsInstruction, type ParsedRatchetInstruction, type ParsedReclaimStairArrayInstruction, type ParsedRegisterPoolInstruction, type ParsedResolveRecipientInstruction, type ParsedResolveStairPayeeInstruction, type ParsedRetireQuoteInstruction, type ParsedSeedFloorInstruction, type ParsedSeedInventoryInstruction, type ParsedSeedLiquidityInstruction, type ParsedSetAllowAllQuotesInstruction, type ParsedSetGenesisStairInstruction, type ParsedSetHookGovernanceInstruction, type ParsedSetQuoteEconomicsInstruction, type ParsedSetTeamTreasuryGovernanceInstruction, type ParsedSetTreasuryGovernanceInstruction, type ParsedSweepPlatformCutInstruction, type ParsedSweepStairFeesInstruction, type ParsedSweepStairPayeeInstruction, type ParsedSweepTraderReferralInstruction, type ParsedTwapTickInstruction, type ParsedWithdrawPlatformInstruction, type ParsedWithdrawStairTokensInstruction, type ParsedWithdrawTeamInstruction, type PayHolderAsyncInput, type PayHolderAuthorizedAsyncInput, type PreparePositionsAsyncInput, type RatchetAsyncInput, type ReclaimStairArrayAsyncInput, type RegisterPoolAsyncInput, type ResolveRecipientAsyncInput, type ResolveStairPayeeAsyncInput, type RetireQuoteAsyncInput, type SeedFloorInput, type SeedInventoryAsyncInput, type SeedLiquidityAsyncInput, type SetAllowAllQuotesAsyncInput, type SetGenesisStairAsyncInput, type SetHookGovernanceAsyncInput, type SetQuoteEconomicsAsyncInput, type SetTeamTreasuryGovernanceAsyncInput, type SetTreasuryGovernanceAsyncInput, type SweepPlatformCutAsyncInput, type SweepStairFeesAsyncInput, type SweepStairPayeeAsyncInput, type SweepTraderReferralAsyncInput, type TwapTickInput, type WithdrawPlatformAsyncInput, type WithdrawStairTokensAsyncInput, type WithdrawTeamAsyncInput } from '../instructions/index.js';
+import { findFloorPlatformPoolPda, findHookAuthorityPda, findHookConfigPda, findPlatformTreasuryPda, findQuotePolicyPda, findStairRentPda, findTeamTreasuryPda, findVaultAuthorityPda } from '../pdas/index.js';
+
+export const FLOOR_HOOK_PROGRAM_ADDRESS = '9uXLyyZginMWdUeu22kp7XV7cpV8183xfsVqUxKi5Viy' as Address<'9uXLyyZginMWdUeu22kp7XV7cpV8183xfsVqUxKi5Viy'>;
+
+export enum FloorHookAccount { FloorPlatformPool, FloorPool, HookConfig, PlatformTreasury, QuotePolicy }
+
+export function identifyFloorHookAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): FloorHookAccount {
+    const data = 'data' in account ? account.data : account;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([167, 208, 168, 33, 137, 35, 5, 31])), 0)) { return FloorHookAccount.FloorPlatformPool; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([115, 235, 216, 23, 209, 113, 149, 196])), 0)) { return FloorHookAccount.FloorPool; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([137, 155, 101, 95, 138, 72, 8, 182])), 0)) { return FloorHookAccount.HookConfig; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([35, 229, 15, 221, 215, 174, 167, 92])), 0)) { return FloorHookAccount.PlatformTreasury; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([1, 43, 26, 79, 86, 39, 171, 67])), 0)) { return FloorHookAccount.QuotePolicy; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "floorHook" });
+}
+
+export enum FloorHookEvent { AllowAllQuotesSet, BidReplaced, CreatorClaimed, CreatorFee, FloorPoolDesignated, FloorUnbacked, HolderPaid, HookConfigInitialized, HookGovernanceChanged, InventoryDonated, PlatformCut, PlatformPoolCredit, PlatformSwept, PlatformWithdrawn, PolRaised, PoolReferralTiers, PoolRegistered, PoolRewardsTerms, QuoteAdmitted, QuoteEconomicsSet, QuoteListed, QuoteObserved, QuoteRetired, Ratcheted, RecipientResolved, ReferralFunded, ReferralPaid, ReferralTierPaid, Skimmed, StairArrayReclaimed, StairFeesSwept, StairOwnerBooked, StairOwnersPlaced, StairPayeeResolved, StairPayeeSwept, StairRatcheted, StairRentReimbursed, StairTokensWithdrawn, TeamSwept, TeamWithdrawn, TraderReferralBooked, TraderReferralClaimed, TraderReferralSwept, TreasuryGovernanceChanged, VaultTokensFed }
+
+export function identifyFloorHookEvent(event: { data: ReadonlyUint8Array } | ReadonlyUint8Array): FloorHookEvent {
+    const data = 'data' in event ? event.data : event;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([63, 102, 30, 237, 21, 111, 253, 253])), 0)) { return FloorHookEvent.AllowAllQuotesSet; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([100, 48, 132, 155, 12, 233, 226, 146])), 0)) { return FloorHookEvent.BidReplaced; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([118, 206, 30, 219, 62, 164, 54, 200])), 0)) { return FloorHookEvent.CreatorClaimed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([181, 41, 130, 175, 119, 58, 243, 107])), 0)) { return FloorHookEvent.CreatorFee; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([109, 137, 79, 14, 21, 109, 142, 178])), 0)) { return FloorHookEvent.FloorPoolDesignated; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([2, 124, 72, 133, 47, 250, 221, 180])), 0)) { return FloorHookEvent.FloorUnbacked; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([123, 31, 51, 115, 81, 117, 179, 144])), 0)) { return FloorHookEvent.HolderPaid; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([229, 103, 225, 17, 30, 200, 107, 228])), 0)) { return FloorHookEvent.HookConfigInitialized; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([165, 216, 204, 61, 232, 63, 23, 130])), 0)) { return FloorHookEvent.HookGovernanceChanged; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 147, 58, 127, 5, 137, 5, 181])), 0)) { return FloorHookEvent.InventoryDonated; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([116, 180, 188, 171, 49, 248, 190, 57])), 0)) { return FloorHookEvent.PlatformCut; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([247, 103, 157, 120, 202, 110, 161, 241])), 0)) { return FloorHookEvent.PlatformPoolCredit; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([17, 36, 171, 186, 88, 150, 115, 161])), 0)) { return FloorHookEvent.PlatformSwept; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([176, 67, 220, 35, 138, 196, 197, 217])), 0)) { return FloorHookEvent.PlatformWithdrawn; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([213, 179, 196, 171, 134, 37, 253, 189])), 0)) { return FloorHookEvent.PolRaised; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([47, 166, 146, 215, 140, 35, 33, 246])), 0)) { return FloorHookEvent.PoolReferralTiers; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([77, 114, 165, 230, 33, 230, 135, 215])), 0)) { return FloorHookEvent.PoolRegistered; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([249, 231, 129, 219, 249, 107, 146, 119])), 0)) { return FloorHookEvent.PoolRewardsTerms; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([150, 5, 185, 145, 39, 182, 72, 153])), 0)) { return FloorHookEvent.QuoteAdmitted; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([0, 62, 82, 42, 83, 173, 199, 176])), 0)) { return FloorHookEvent.QuoteEconomicsSet; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([112, 205, 108, 69, 157, 225, 211, 77])), 0)) { return FloorHookEvent.QuoteListed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([246, 133, 31, 188, 56, 75, 194, 57])), 0)) { return FloorHookEvent.QuoteObserved; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([150, 48, 137, 136, 102, 205, 153, 116])), 0)) { return FloorHookEvent.QuoteRetired; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([179, 132, 213, 65, 217, 49, 192, 119])), 0)) { return FloorHookEvent.Ratcheted; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([89, 82, 171, 46, 227, 2, 190, 102])), 0)) { return FloorHookEvent.RecipientResolved; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([218, 125, 162, 228, 39, 127, 169, 65])), 0)) { return FloorHookEvent.ReferralFunded; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([70, 190, 133, 42, 145, 213, 87, 197])), 0)) { return FloorHookEvent.ReferralPaid; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([81, 109, 199, 194, 143, 238, 253, 168])), 0)) { return FloorHookEvent.ReferralTierPaid; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([25, 39, 18, 44, 46, 131, 59, 76])), 0)) { return FloorHookEvent.Skimmed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([149, 123, 164, 66, 184, 36, 6, 110])), 0)) { return FloorHookEvent.StairArrayReclaimed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([104, 41, 80, 196, 160, 32, 109, 6])), 0)) { return FloorHookEvent.StairFeesSwept; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([116, 197, 26, 134, 204, 56, 4, 122])), 0)) { return FloorHookEvent.StairOwnerBooked; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([212, 177, 238, 143, 44, 53, 132, 56])), 0)) { return FloorHookEvent.StairOwnersPlaced; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([91, 184, 83, 103, 234, 32, 248, 228])), 0)) { return FloorHookEvent.StairPayeeResolved; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([105, 21, 203, 238, 99, 227, 180, 198])), 0)) { return FloorHookEvent.StairPayeeSwept; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([170, 24, 1, 196, 211, 194, 192, 101])), 0)) { return FloorHookEvent.StairRatcheted; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([68, 248, 141, 84, 185, 42, 205, 91])), 0)) { return FloorHookEvent.StairRentReimbursed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([150, 121, 122, 29, 92, 222, 245, 103])), 0)) { return FloorHookEvent.StairTokensWithdrawn; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([91, 151, 177, 113, 223, 98, 155, 173])), 0)) { return FloorHookEvent.TeamSwept; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([81, 96, 11, 34, 127, 203, 158, 3])), 0)) { return FloorHookEvent.TeamWithdrawn; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([188, 87, 241, 203, 166, 90, 101, 83])), 0)) { return FloorHookEvent.TraderReferralBooked; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([126, 52, 40, 101, 193, 4, 7, 220])), 0)) { return FloorHookEvent.TraderReferralClaimed; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([244, 206, 16, 90, 123, 74, 32, 160])), 0)) { return FloorHookEvent.TraderReferralSwept; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([139, 253, 142, 226, 247, 103, 163, 237])), 0)) { return FloorHookEvent.TreasuryGovernanceChanged; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([182, 123, 9, 3, 157, 120, 47, 112])), 0)) { return FloorHookEvent.VaultTokensFed; }
+    throw new Error('The provided event could not be identified as a floorHook event.');
+}
+
+export enum FloorHookInstruction { AcceptHookGovernance, AcceptTeamTreasuryGovernance, AcceptTreasuryGovernance, AfterActions, AfterSwap, BeforeInitialize, BeforeSwap, ClaimCreatorFees, ClaimReferralFees, ClaimTraderReferral, ClearTeamBuyBooks, CreditFloorPool, CreditTraderBucket, DesignateFloorPool, DonateInventory, InitializeHookConfig, InitializeTeamTreasury, ListQuote, ObserveQuote, OpenTraderBucket, OpenTraderRefVault, PayHolder, PayHolderAuthorized, PreparePositions, Ratchet, ReclaimStairArray, RegisterPool, ResolveRecipient, ResolveStairPayee, RetireQuote, SeedFloor, SeedInventory, SeedLiquidity, SetAllowAllQuotes, SetGenesisStair, SetHookGovernance, SetQuoteEconomics, SetTeamTreasuryGovernance, SetTreasuryGovernance, SweepPlatformCut, SweepStairFees, SweepStairPayee, SweepTraderReferral, TwapTick, WithdrawPlatform, WithdrawStairTokens, WithdrawTeam }
+
+export function identifyFloorHookInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): FloorHookInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([68, 39, 99, 106, 109, 166, 67, 144])), 0)) { return FloorHookInstruction.AcceptHookGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([51, 65, 175, 181, 184, 59, 211, 160])), 0)) { return FloorHookInstruction.AcceptTeamTreasuryGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([108, 248, 168, 54, 40, 251, 153, 230])), 0)) { return FloorHookInstruction.AcceptTreasuryGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([97, 150, 206, 96, 145, 2, 36, 0])), 0)) { return FloorHookInstruction.AfterActions; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([235, 215, 232, 183, 152, 109, 5, 35])), 0)) { return FloorHookInstruction.AfterSwap; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([34, 92, 163, 44, 187, 213, 131, 15])), 0)) { return FloorHookInstruction.BeforeInitialize; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([227, 59, 240, 68, 164, 9, 29, 254])), 0)) { return FloorHookInstruction.BeforeSwap; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([0, 23, 125, 234, 156, 118, 134, 89])), 0)) { return FloorHookInstruction.ClaimCreatorFees; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([208, 216, 137, 78, 36, 103, 162, 49])), 0)) { return FloorHookInstruction.ClaimReferralFees; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 66, 37, 249, 5, 183, 182, 159])), 0)) { return FloorHookInstruction.ClaimTraderReferral; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([178, 232, 64, 205, 77, 42, 79, 194])), 0)) { return FloorHookInstruction.ClearTeamBuyBooks; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([161, 58, 10, 130, 16, 116, 201, 172])), 0)) { return FloorHookInstruction.CreditFloorPool; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([217, 90, 20, 3, 100, 143, 255, 160])), 0)) { return FloorHookInstruction.CreditTraderBucket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([138, 82, 114, 183, 68, 174, 165, 252])), 0)) { return FloorHookInstruction.DesignateFloorPool; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([1, 163, 182, 81, 113, 1, 181, 52])), 0)) { return FloorHookInstruction.DonateInventory; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([144, 239, 17, 85, 228, 48, 54, 43])), 0)) { return FloorHookInstruction.InitializeHookConfig; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([181, 38, 107, 149, 172, 123, 246, 161])), 0)) { return FloorHookInstruction.InitializeTeamTreasury; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([113, 5, 184, 196, 204, 185, 105, 137])), 0)) { return FloorHookInstruction.ListQuote; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([71, 241, 86, 116, 188, 71, 134, 30])), 0)) { return FloorHookInstruction.ObserveQuote; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([42, 108, 178, 229, 110, 153, 18, 169])), 0)) { return FloorHookInstruction.OpenTraderBucket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([243, 155, 101, 210, 116, 60, 251, 42])), 0)) { return FloorHookInstruction.OpenTraderRefVault; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([200, 10, 93, 192, 80, 148, 8, 75])), 0)) { return FloorHookInstruction.PayHolder; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([90, 160, 177, 182, 35, 33, 10, 229])), 0)) { return FloorHookInstruction.PayHolderAuthorized; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([75, 27, 188, 109, 156, 46, 32, 17])), 0)) { return FloorHookInstruction.PreparePositions; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([221, 214, 205, 110, 12, 170, 24, 173])), 0)) { return FloorHookInstruction.Ratchet; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([31, 41, 2, 166, 95, 99, 162, 206])), 0)) { return FloorHookInstruction.ReclaimStairArray; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([85, 229, 114, 47, 75, 145, 166, 100])), 0)) { return FloorHookInstruction.RegisterPool; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([110, 145, 73, 134, 188, 220, 168, 99])), 0)) { return FloorHookInstruction.ResolveRecipient; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([49, 91, 184, 220, 191, 111, 5, 29])), 0)) { return FloorHookInstruction.ResolveStairPayee; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([174, 158, 168, 112, 142, 220, 96, 100])), 0)) { return FloorHookInstruction.RetireQuote; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([101, 126, 192, 195, 248, 9, 142, 74])), 0)) { return FloorHookInstruction.SeedFloor; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([87, 71, 204, 35, 81, 40, 12, 106])), 0)) { return FloorHookInstruction.SeedInventory; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([180, 57, 94, 35, 73, 48, 13, 11])), 0)) { return FloorHookInstruction.SeedLiquidity; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([102, 127, 128, 72, 24, 176, 210, 33])), 0)) { return FloorHookInstruction.SetAllowAllQuotes; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([194, 7, 219, 132, 245, 101, 253, 151])), 0)) { return FloorHookInstruction.SetGenesisStair; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([36, 180, 224, 192, 140, 222, 62, 41])), 0)) { return FloorHookInstruction.SetHookGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([84, 84, 141, 132, 123, 180, 32, 207])), 0)) { return FloorHookInstruction.SetQuoteEconomics; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([4, 57, 18, 29, 66, 49, 236, 196])), 0)) { return FloorHookInstruction.SetTeamTreasuryGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([142, 144, 161, 230, 107, 13, 134, 50])), 0)) { return FloorHookInstruction.SetTreasuryGovernance; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([3, 223, 35, 201, 74, 243, 19, 132])), 0)) { return FloorHookInstruction.SweepPlatformCut; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([38, 23, 188, 194, 47, 37, 113, 248])), 0)) { return FloorHookInstruction.SweepStairFees; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([163, 11, 126, 43, 140, 173, 217, 80])), 0)) { return FloorHookInstruction.SweepStairPayee; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([51, 112, 24, 253, 196, 122, 164, 167])), 0)) { return FloorHookInstruction.SweepTraderReferral; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([108, 83, 246, 20, 14, 81, 241, 189])), 0)) { return FloorHookInstruction.TwapTick; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([87, 237, 31, 212, 241, 172, 99, 33])), 0)) { return FloorHookInstruction.WithdrawPlatform; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([138, 213, 80, 208, 193, 98, 202, 41])), 0)) { return FloorHookInstruction.WithdrawStairTokens; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([132, 156, 138, 250, 32, 15, 101, 35])), 0)) { return FloorHookInstruction.WithdrawTeam; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "floorHook" });
+}
+
+export type ParsedFloorHookInstruction<TProgram extends string = '9uXLyyZginMWdUeu22kp7XV7cpV8183xfsVqUxKi5Viy'> =
+| { instructionType: FloorHookInstruction.AcceptHookGovernance } & ParsedAcceptHookGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.AcceptTeamTreasuryGovernance } & ParsedAcceptTeamTreasuryGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.AcceptTreasuryGovernance } & ParsedAcceptTreasuryGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.AfterActions } & ParsedAfterActionsInstruction<TProgram>
+| { instructionType: FloorHookInstruction.AfterSwap } & ParsedAfterSwapInstruction<TProgram>
+| { instructionType: FloorHookInstruction.BeforeInitialize } & ParsedBeforeInitializeInstruction<TProgram>
+| { instructionType: FloorHookInstruction.BeforeSwap } & ParsedBeforeSwapInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ClaimCreatorFees } & ParsedClaimCreatorFeesInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ClaimReferralFees } & ParsedClaimReferralFeesInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ClaimTraderReferral } & ParsedClaimTraderReferralInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ClearTeamBuyBooks } & ParsedClearTeamBuyBooksInstruction<TProgram>
+| { instructionType: FloorHookInstruction.CreditFloorPool } & ParsedCreditFloorPoolInstruction<TProgram>
+| { instructionType: FloorHookInstruction.CreditTraderBucket } & ParsedCreditTraderBucketInstruction<TProgram>
+| { instructionType: FloorHookInstruction.DesignateFloorPool } & ParsedDesignateFloorPoolInstruction<TProgram>
+| { instructionType: FloorHookInstruction.DonateInventory } & ParsedDonateInventoryInstruction<TProgram>
+| { instructionType: FloorHookInstruction.InitializeHookConfig } & ParsedInitializeHookConfigInstruction<TProgram>
+| { instructionType: FloorHookInstruction.InitializeTeamTreasury } & ParsedInitializeTeamTreasuryInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ListQuote } & ParsedListQuoteInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ObserveQuote } & ParsedObserveQuoteInstruction<TProgram>
+| { instructionType: FloorHookInstruction.OpenTraderBucket } & ParsedOpenTraderBucketInstruction<TProgram>
+| { instructionType: FloorHookInstruction.OpenTraderRefVault } & ParsedOpenTraderRefVaultInstruction<TProgram>
+| { instructionType: FloorHookInstruction.PayHolder } & ParsedPayHolderInstruction<TProgram>
+| { instructionType: FloorHookInstruction.PayHolderAuthorized } & ParsedPayHolderAuthorizedInstruction<TProgram>
+| { instructionType: FloorHookInstruction.PreparePositions } & ParsedPreparePositionsInstruction<TProgram>
+| { instructionType: FloorHookInstruction.Ratchet } & ParsedRatchetInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ReclaimStairArray } & ParsedReclaimStairArrayInstruction<TProgram>
+| { instructionType: FloorHookInstruction.RegisterPool } & ParsedRegisterPoolInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ResolveRecipient } & ParsedResolveRecipientInstruction<TProgram>
+| { instructionType: FloorHookInstruction.ResolveStairPayee } & ParsedResolveStairPayeeInstruction<TProgram>
+| { instructionType: FloorHookInstruction.RetireQuote } & ParsedRetireQuoteInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SeedFloor } & ParsedSeedFloorInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SeedInventory } & ParsedSeedInventoryInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SeedLiquidity } & ParsedSeedLiquidityInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetAllowAllQuotes } & ParsedSetAllowAllQuotesInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetGenesisStair } & ParsedSetGenesisStairInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetHookGovernance } & ParsedSetHookGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetQuoteEconomics } & ParsedSetQuoteEconomicsInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetTeamTreasuryGovernance } & ParsedSetTeamTreasuryGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SetTreasuryGovernance } & ParsedSetTreasuryGovernanceInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SweepPlatformCut } & ParsedSweepPlatformCutInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SweepStairFees } & ParsedSweepStairFeesInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SweepStairPayee } & ParsedSweepStairPayeeInstruction<TProgram>
+| { instructionType: FloorHookInstruction.SweepTraderReferral } & ParsedSweepTraderReferralInstruction<TProgram>
+| { instructionType: FloorHookInstruction.TwapTick } & ParsedTwapTickInstruction<TProgram>
+| { instructionType: FloorHookInstruction.WithdrawPlatform } & ParsedWithdrawPlatformInstruction<TProgram>
+| { instructionType: FloorHookInstruction.WithdrawStairTokens } & ParsedWithdrawStairTokensInstruction<TProgram>
+| { instructionType: FloorHookInstruction.WithdrawTeam } & ParsedWithdrawTeamInstruction<TProgram>
+
+
+        export function parseFloorHookInstruction<TProgram extends string>(
+            instruction: Instruction<TProgram> 
+                & InstructionWithData<ReadonlyUint8Array>
+        ): ParsedFloorHookInstruction<TProgram> {
+            const instructionType = identifyFloorHookInstruction(instruction);
+            switch (instructionType) {
+                case FloorHookInstruction.AcceptHookGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.AcceptHookGovernance, ...parseAcceptHookGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.AcceptTeamTreasuryGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.AcceptTeamTreasuryGovernance, ...parseAcceptTeamTreasuryGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.AcceptTreasuryGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.AcceptTreasuryGovernance, ...parseAcceptTreasuryGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.AfterActions: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.AfterActions, ...parseAfterActionsInstruction(instruction) }; }
+case FloorHookInstruction.AfterSwap: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.AfterSwap, ...parseAfterSwapInstruction(instruction) }; }
+case FloorHookInstruction.BeforeInitialize: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.BeforeInitialize, ...parseBeforeInitializeInstruction(instruction) }; }
+case FloorHookInstruction.BeforeSwap: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.BeforeSwap, ...parseBeforeSwapInstruction(instruction) }; }
+case FloorHookInstruction.ClaimCreatorFees: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ClaimCreatorFees, ...parseClaimCreatorFeesInstruction(instruction) }; }
+case FloorHookInstruction.ClaimReferralFees: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ClaimReferralFees, ...parseClaimReferralFeesInstruction(instruction) }; }
+case FloorHookInstruction.ClaimTraderReferral: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ClaimTraderReferral, ...parseClaimTraderReferralInstruction(instruction) }; }
+case FloorHookInstruction.ClearTeamBuyBooks: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ClearTeamBuyBooks, ...parseClearTeamBuyBooksInstruction(instruction) }; }
+case FloorHookInstruction.CreditFloorPool: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.CreditFloorPool, ...parseCreditFloorPoolInstruction(instruction) }; }
+case FloorHookInstruction.CreditTraderBucket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.CreditTraderBucket, ...parseCreditTraderBucketInstruction(instruction) }; }
+case FloorHookInstruction.DesignateFloorPool: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.DesignateFloorPool, ...parseDesignateFloorPoolInstruction(instruction) }; }
+case FloorHookInstruction.DonateInventory: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.DonateInventory, ...parseDonateInventoryInstruction(instruction) }; }
+case FloorHookInstruction.InitializeHookConfig: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.InitializeHookConfig, ...parseInitializeHookConfigInstruction(instruction) }; }
+case FloorHookInstruction.InitializeTeamTreasury: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.InitializeTeamTreasury, ...parseInitializeTeamTreasuryInstruction(instruction) }; }
+case FloorHookInstruction.ListQuote: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ListQuote, ...parseListQuoteInstruction(instruction) }; }
+case FloorHookInstruction.ObserveQuote: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ObserveQuote, ...parseObserveQuoteInstruction(instruction) }; }
+case FloorHookInstruction.OpenTraderBucket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.OpenTraderBucket, ...parseOpenTraderBucketInstruction(instruction) }; }
+case FloorHookInstruction.OpenTraderRefVault: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.OpenTraderRefVault, ...parseOpenTraderRefVaultInstruction(instruction) }; }
+case FloorHookInstruction.PayHolder: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.PayHolder, ...parsePayHolderInstruction(instruction) }; }
+case FloorHookInstruction.PayHolderAuthorized: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.PayHolderAuthorized, ...parsePayHolderAuthorizedInstruction(instruction) }; }
+case FloorHookInstruction.PreparePositions: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.PreparePositions, ...parsePreparePositionsInstruction(instruction) }; }
+case FloorHookInstruction.Ratchet: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.Ratchet, ...parseRatchetInstruction(instruction) }; }
+case FloorHookInstruction.ReclaimStairArray: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ReclaimStairArray, ...parseReclaimStairArrayInstruction(instruction) }; }
+case FloorHookInstruction.RegisterPool: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.RegisterPool, ...parseRegisterPoolInstruction(instruction) }; }
+case FloorHookInstruction.ResolveRecipient: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ResolveRecipient, ...parseResolveRecipientInstruction(instruction) }; }
+case FloorHookInstruction.ResolveStairPayee: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.ResolveStairPayee, ...parseResolveStairPayeeInstruction(instruction) }; }
+case FloorHookInstruction.RetireQuote: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.RetireQuote, ...parseRetireQuoteInstruction(instruction) }; }
+case FloorHookInstruction.SeedFloor: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SeedFloor, ...parseSeedFloorInstruction(instruction) }; }
+case FloorHookInstruction.SeedInventory: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SeedInventory, ...parseSeedInventoryInstruction(instruction) }; }
+case FloorHookInstruction.SeedLiquidity: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SeedLiquidity, ...parseSeedLiquidityInstruction(instruction) }; }
+case FloorHookInstruction.SetAllowAllQuotes: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetAllowAllQuotes, ...parseSetAllowAllQuotesInstruction(instruction) }; }
+case FloorHookInstruction.SetGenesisStair: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetGenesisStair, ...parseSetGenesisStairInstruction(instruction) }; }
+case FloorHookInstruction.SetHookGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetHookGovernance, ...parseSetHookGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.SetQuoteEconomics: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetQuoteEconomics, ...parseSetQuoteEconomicsInstruction(instruction) }; }
+case FloorHookInstruction.SetTeamTreasuryGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetTeamTreasuryGovernance, ...parseSetTeamTreasuryGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.SetTreasuryGovernance: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SetTreasuryGovernance, ...parseSetTreasuryGovernanceInstruction(instruction) }; }
+case FloorHookInstruction.SweepPlatformCut: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SweepPlatformCut, ...parseSweepPlatformCutInstruction(instruction) }; }
+case FloorHookInstruction.SweepStairFees: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SweepStairFees, ...parseSweepStairFeesInstruction(instruction) }; }
+case FloorHookInstruction.SweepStairPayee: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SweepStairPayee, ...parseSweepStairPayeeInstruction(instruction) }; }
+case FloorHookInstruction.SweepTraderReferral: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.SweepTraderReferral, ...parseSweepTraderReferralInstruction(instruction) }; }
+case FloorHookInstruction.TwapTick: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.TwapTick, ...parseTwapTickInstruction(instruction) }; }
+case FloorHookInstruction.WithdrawPlatform: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.WithdrawPlatform, ...parseWithdrawPlatformInstruction(instruction) }; }
+case FloorHookInstruction.WithdrawStairTokens: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.WithdrawStairTokens, ...parseWithdrawStairTokensInstruction(instruction) }; }
+case FloorHookInstruction.WithdrawTeam: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: FloorHookInstruction.WithdrawTeam, ...parseWithdrawTeamInstruction(instruction) }; }
+                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: "floorHook" });
+            }
+        }
+
+export type FloorHookPlugin = { accounts: FloorHookPluginAccounts; instructions: FloorHookPluginInstructions; pdas: FloorHookPluginPdas; identifyAccount: typeof identifyFloorHookAccount; identifyInstruction: typeof identifyFloorHookInstruction; parseInstruction: typeof parseFloorHookInstruction; }
+
+export type FloorHookPluginAccounts = { floorPlatformPool: ReturnType<typeof getFloorPlatformPoolCodec> & SelfFetchFunctions<FloorPlatformPoolArgs, FloorPlatformPool>; floorPool: ReturnType<typeof getFloorPoolCodec> & SelfFetchFunctions<FloorPoolArgs, FloorPool>; hookConfig: ReturnType<typeof getHookConfigCodec> & SelfFetchFunctions<HookConfigArgs, HookConfig>; platformTreasury: ReturnType<typeof getPlatformTreasuryCodec> & SelfFetchFunctions<PlatformTreasuryArgs, PlatformTreasury>; quotePolicy: ReturnType<typeof getQuotePolicyCodec> & SelfFetchFunctions<QuotePolicyArgs, QuotePolicy>; }
+
+export type FloorHookPluginInstructions = { acceptHookGovernance: (input: AcceptHookGovernanceAsyncInput) => ReturnType<typeof getAcceptHookGovernanceInstructionAsync> & SelfPlanAndSendFunctions; acceptTeamTreasuryGovernance: (input: AcceptTeamTreasuryGovernanceAsyncInput) => ReturnType<typeof getAcceptTeamTreasuryGovernanceInstructionAsync> & SelfPlanAndSendFunctions; acceptTreasuryGovernance: (input: AcceptTreasuryGovernanceAsyncInput) => ReturnType<typeof getAcceptTreasuryGovernanceInstructionAsync> & SelfPlanAndSendFunctions; afterActions: (input: AfterActionsInput) => ReturnType<typeof getAfterActionsInstruction> & SelfPlanAndSendFunctions; afterSwap: (input: AfterSwapInput) => ReturnType<typeof getAfterSwapInstruction> & SelfPlanAndSendFunctions; beforeInitialize: (input: BeforeInitializeInput) => ReturnType<typeof getBeforeInitializeInstruction> & SelfPlanAndSendFunctions; beforeSwap: (input: BeforeSwapInput) => ReturnType<typeof getBeforeSwapInstruction> & SelfPlanAndSendFunctions; claimCreatorFees: (input: ClaimCreatorFeesAsyncInput) => ReturnType<typeof getClaimCreatorFeesInstructionAsync> & SelfPlanAndSendFunctions; claimReferralFees: (input: ClaimReferralFeesAsyncInput) => ReturnType<typeof getClaimReferralFeesInstructionAsync> & SelfPlanAndSendFunctions; claimTraderReferral: (input: ClaimTraderReferralAsyncInput) => ReturnType<typeof getClaimTraderReferralInstructionAsync> & SelfPlanAndSendFunctions; clearTeamBuyBooks: (input: ClearTeamBuyBooksAsyncInput) => ReturnType<typeof getClearTeamBuyBooksInstructionAsync> & SelfPlanAndSendFunctions; creditFloorPool: (input: CreditFloorPoolAsyncInput) => ReturnType<typeof getCreditFloorPoolInstructionAsync> & SelfPlanAndSendFunctions; creditTraderBucket: (input: CreditTraderBucketAsyncInput) => ReturnType<typeof getCreditTraderBucketInstructionAsync> & SelfPlanAndSendFunctions; designateFloorPool: (input: MakeOptional<DesignateFloorPoolAsyncInput, "payer">) => ReturnType<typeof getDesignateFloorPoolInstructionAsync> & SelfPlanAndSendFunctions; donateInventory: (input: DonateInventoryInput) => ReturnType<typeof getDonateInventoryInstruction> & SelfPlanAndSendFunctions; initializeHookConfig: (input: InitializeHookConfigAsyncInput) => ReturnType<typeof getInitializeHookConfigInstructionAsync> & SelfPlanAndSendFunctions; initializeTeamTreasury: (input: InitializeTeamTreasuryAsyncInput) => ReturnType<typeof getInitializeTeamTreasuryInstructionAsync> & SelfPlanAndSendFunctions; listQuote: (input: MakeOptional<ListQuoteAsyncInput, "payer">) => ReturnType<typeof getListQuoteInstructionAsync> & SelfPlanAndSendFunctions; observeQuote: (input: ObserveQuoteInput) => ReturnType<typeof getObserveQuoteInstruction> & SelfPlanAndSendFunctions; openTraderBucket: (input: MakeOptional<OpenTraderBucketInput, "payer">) => ReturnType<typeof getOpenTraderBucketInstruction> & SelfPlanAndSendFunctions; openTraderRefVault: (input: MakeOptional<OpenTraderRefVaultAsyncInput, "payer">) => ReturnType<typeof getOpenTraderRefVaultInstructionAsync> & SelfPlanAndSendFunctions; payHolder: (input: PayHolderAsyncInput) => ReturnType<typeof getPayHolderInstructionAsync> & SelfPlanAndSendFunctions; payHolderAuthorized: (input: PayHolderAuthorizedAsyncInput) => ReturnType<typeof getPayHolderAuthorizedInstructionAsync> & SelfPlanAndSendFunctions; preparePositions: (input: MakeOptional<PreparePositionsAsyncInput, "payer">) => ReturnType<typeof getPreparePositionsInstructionAsync> & SelfPlanAndSendFunctions; ratchet: (input: RatchetAsyncInput) => ReturnType<typeof getRatchetInstructionAsync> & SelfPlanAndSendFunctions; reclaimStairArray: (input: ReclaimStairArrayAsyncInput) => ReturnType<typeof getReclaimStairArrayInstructionAsync> & SelfPlanAndSendFunctions; registerPool: (input: MakeOptional<RegisterPoolAsyncInput, "payer">) => ReturnType<typeof getRegisterPoolInstructionAsync> & SelfPlanAndSendFunctions; resolveRecipient: (input: ResolveRecipientAsyncInput) => ReturnType<typeof getResolveRecipientInstructionAsync> & SelfPlanAndSendFunctions; resolveStairPayee: (input: ResolveStairPayeeAsyncInput) => ReturnType<typeof getResolveStairPayeeInstructionAsync> & SelfPlanAndSendFunctions; retireQuote: (input: RetireQuoteAsyncInput) => ReturnType<typeof getRetireQuoteInstructionAsync> & SelfPlanAndSendFunctions; seedFloor: (input: SeedFloorInput) => ReturnType<typeof getSeedFloorInstruction> & SelfPlanAndSendFunctions; seedInventory: (input: MakeOptional<SeedInventoryAsyncInput, "payer">) => ReturnType<typeof getSeedInventoryInstructionAsync> & SelfPlanAndSendFunctions; seedLiquidity: (input: MakeOptional<SeedLiquidityAsyncInput, "payer">) => ReturnType<typeof getSeedLiquidityInstructionAsync> & SelfPlanAndSendFunctions; setAllowAllQuotes: (input: SetAllowAllQuotesAsyncInput) => ReturnType<typeof getSetAllowAllQuotesInstructionAsync> & SelfPlanAndSendFunctions; setGenesisStair: (input: SetGenesisStairAsyncInput) => ReturnType<typeof getSetGenesisStairInstructionAsync> & SelfPlanAndSendFunctions; setHookGovernance: (input: SetHookGovernanceAsyncInput) => ReturnType<typeof getSetHookGovernanceInstructionAsync> & SelfPlanAndSendFunctions; setQuoteEconomics: (input: SetQuoteEconomicsAsyncInput) => ReturnType<typeof getSetQuoteEconomicsInstructionAsync> & SelfPlanAndSendFunctions; setTeamTreasuryGovernance: (input: SetTeamTreasuryGovernanceAsyncInput) => ReturnType<typeof getSetTeamTreasuryGovernanceInstructionAsync> & SelfPlanAndSendFunctions; setTreasuryGovernance: (input: SetTreasuryGovernanceAsyncInput) => ReturnType<typeof getSetTreasuryGovernanceInstructionAsync> & SelfPlanAndSendFunctions; sweepPlatformCut: (input: SweepPlatformCutAsyncInput) => ReturnType<typeof getSweepPlatformCutInstructionAsync> & SelfPlanAndSendFunctions; sweepStairFees: (input: SweepStairFeesAsyncInput) => ReturnType<typeof getSweepStairFeesInstructionAsync> & SelfPlanAndSendFunctions; sweepStairPayee: (input: SweepStairPayeeAsyncInput) => ReturnType<typeof getSweepStairPayeeInstructionAsync> & SelfPlanAndSendFunctions; sweepTraderReferral: (input: SweepTraderReferralAsyncInput) => ReturnType<typeof getSweepTraderReferralInstructionAsync> & SelfPlanAndSendFunctions; twapTick: (input: TwapTickInput) => ReturnType<typeof getTwapTickInstruction> & SelfPlanAndSendFunctions; withdrawPlatform: (input: WithdrawPlatformAsyncInput) => ReturnType<typeof getWithdrawPlatformInstructionAsync> & SelfPlanAndSendFunctions; withdrawStairTokens: (input: WithdrawStairTokensAsyncInput) => ReturnType<typeof getWithdrawStairTokensInstructionAsync> & SelfPlanAndSendFunctions; withdrawTeam: (input: WithdrawTeamAsyncInput) => ReturnType<typeof getWithdrawTeamInstructionAsync> & SelfPlanAndSendFunctions; }
+
+export type FloorHookPluginPdas = { hookConfig: typeof findHookConfigPda; teamTreasury: typeof findTeamTreasuryPda; platformTreasury: typeof findPlatformTreasuryPda; hookAuthority: typeof findHookAuthorityPda; vaultAuthority: typeof findVaultAuthorityPda; floorPlatformPool: typeof findFloorPlatformPoolPda; quotePolicy: typeof findQuotePolicyPda; stairRent: typeof findStairRentPda; }
+
+export type FloorHookPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending
+
+export function floorHookProgram() {
+    return <T extends FloorHookPluginRequirements>(client: T): ExtendedClient<T, { floorHook: FloorHookPlugin }> => {
+        return extendClient(client, { floorHook: <FloorHookPlugin>{ accounts: { floorPlatformPool: addSelfFetchFunctions(client, getFloorPlatformPoolCodec()), floorPool: addSelfFetchFunctions(client, getFloorPoolCodec()), hookConfig: addSelfFetchFunctions(client, getHookConfigCodec()), platformTreasury: addSelfFetchFunctions(client, getPlatformTreasuryCodec()), quotePolicy: addSelfFetchFunctions(client, getQuotePolicyCodec()) }, instructions: { acceptHookGovernance: input => addSelfPlanAndSendFunctions(client, getAcceptHookGovernanceInstructionAsync(input)), acceptTeamTreasuryGovernance: input => addSelfPlanAndSendFunctions(client, getAcceptTeamTreasuryGovernanceInstructionAsync(input)), acceptTreasuryGovernance: input => addSelfPlanAndSendFunctions(client, getAcceptTreasuryGovernanceInstructionAsync(input)), afterActions: input => addSelfPlanAndSendFunctions(client, getAfterActionsInstruction(input)), afterSwap: input => addSelfPlanAndSendFunctions(client, getAfterSwapInstruction(input)), beforeInitialize: input => addSelfPlanAndSendFunctions(client, getBeforeInitializeInstruction(input)), beforeSwap: input => addSelfPlanAndSendFunctions(client, getBeforeSwapInstruction(input)), claimCreatorFees: input => addSelfPlanAndSendFunctions(client, getClaimCreatorFeesInstructionAsync(input)), claimReferralFees: input => addSelfPlanAndSendFunctions(client, getClaimReferralFeesInstructionAsync(input)), claimTraderReferral: input => addSelfPlanAndSendFunctions(client, getClaimTraderReferralInstructionAsync(input)), clearTeamBuyBooks: input => addSelfPlanAndSendFunctions(client, getClearTeamBuyBooksInstructionAsync(input)), creditFloorPool: input => addSelfPlanAndSendFunctions(client, getCreditFloorPoolInstructionAsync(input)), creditTraderBucket: input => addSelfPlanAndSendFunctions(client, getCreditTraderBucketInstructionAsync(input)), designateFloorPool: input => addSelfPlanAndSendFunctions(client, getDesignateFloorPoolInstructionAsync({ ...input, payer: input.payer ?? client.payer })), donateInventory: input => addSelfPlanAndSendFunctions(client, getDonateInventoryInstruction(input)), initializeHookConfig: input => addSelfPlanAndSendFunctions(client, getInitializeHookConfigInstructionAsync(input)), initializeTeamTreasury: input => addSelfPlanAndSendFunctions(client, getInitializeTeamTreasuryInstructionAsync(input)), listQuote: input => addSelfPlanAndSendFunctions(client, getListQuoteInstructionAsync({ ...input, payer: input.payer ?? client.payer })), observeQuote: input => addSelfPlanAndSendFunctions(client, getObserveQuoteInstruction(input)), openTraderBucket: input => addSelfPlanAndSendFunctions(client, getOpenTraderBucketInstruction({ ...input, payer: input.payer ?? client.payer })), openTraderRefVault: input => addSelfPlanAndSendFunctions(client, getOpenTraderRefVaultInstructionAsync({ ...input, payer: input.payer ?? client.payer })), payHolder: input => addSelfPlanAndSendFunctions(client, getPayHolderInstructionAsync(input)), payHolderAuthorized: input => addSelfPlanAndSendFunctions(client, getPayHolderAuthorizedInstructionAsync(input)), preparePositions: input => addSelfPlanAndSendFunctions(client, getPreparePositionsInstructionAsync({ ...input, payer: input.payer ?? client.payer })), ratchet: input => addSelfPlanAndSendFunctions(client, getRatchetInstructionAsync(input)), reclaimStairArray: input => addSelfPlanAndSendFunctions(client, getReclaimStairArrayInstructionAsync(input)), registerPool: input => addSelfPlanAndSendFunctions(client, getRegisterPoolInstructionAsync({ ...input, payer: input.payer ?? client.payer })), resolveRecipient: input => addSelfPlanAndSendFunctions(client, getResolveRecipientInstructionAsync(input)), resolveStairPayee: input => addSelfPlanAndSendFunctions(client, getResolveStairPayeeInstructionAsync(input)), retireQuote: input => addSelfPlanAndSendFunctions(client, getRetireQuoteInstructionAsync(input)), seedFloor: input => addSelfPlanAndSendFunctions(client, getSeedFloorInstruction(input)), seedInventory: input => addSelfPlanAndSendFunctions(client, getSeedInventoryInstructionAsync({ ...input, payer: input.payer ?? client.payer })), seedLiquidity: input => addSelfPlanAndSendFunctions(client, getSeedLiquidityInstructionAsync({ ...input, payer: input.payer ?? client.payer })), setAllowAllQuotes: input => addSelfPlanAndSendFunctions(client, getSetAllowAllQuotesInstructionAsync(input)), setGenesisStair: input => addSelfPlanAndSendFunctions(client, getSetGenesisStairInstructionAsync(input)), setHookGovernance: input => addSelfPlanAndSendFunctions(client, getSetHookGovernanceInstructionAsync(input)), setQuoteEconomics: input => addSelfPlanAndSendFunctions(client, getSetQuoteEconomicsInstructionAsync(input)), setTeamTreasuryGovernance: input => addSelfPlanAndSendFunctions(client, getSetTeamTreasuryGovernanceInstructionAsync(input)), setTreasuryGovernance: input => addSelfPlanAndSendFunctions(client, getSetTreasuryGovernanceInstructionAsync(input)), sweepPlatformCut: input => addSelfPlanAndSendFunctions(client, getSweepPlatformCutInstructionAsync(input)), sweepStairFees: input => addSelfPlanAndSendFunctions(client, getSweepStairFeesInstructionAsync(input)), sweepStairPayee: input => addSelfPlanAndSendFunctions(client, getSweepStairPayeeInstructionAsync(input)), sweepTraderReferral: input => addSelfPlanAndSendFunctions(client, getSweepTraderReferralInstructionAsync(input)), twapTick: input => addSelfPlanAndSendFunctions(client, getTwapTickInstruction(input)), withdrawPlatform: input => addSelfPlanAndSendFunctions(client, getWithdrawPlatformInstructionAsync(input)), withdrawStairTokens: input => addSelfPlanAndSendFunctions(client, getWithdrawStairTokensInstructionAsync(input)), withdrawTeam: input => addSelfPlanAndSendFunctions(client, getWithdrawTeamInstructionAsync(input)) }, pdas: { hookConfig: findHookConfigPda, teamTreasury: findTeamTreasuryPda, platformTreasury: findPlatformTreasuryPda, hookAuthority: findHookAuthorityPda, vaultAuthority: findVaultAuthorityPda, floorPlatformPool: findFloorPlatformPoolPda, quotePolicy: findQuotePolicyPda, stairRent: findStairRentPda }, identifyAccount: identifyFloorHookAccount, identifyInstruction: identifyFloorHookInstruction, parseInstruction: parseFloorHookInstruction } });
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/client/floor_hook/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 './floorHook.js';

package/src/generated/client/floor_hook/types/actionResult.ts

@@ -0,0 +1,26 @@
+/**
+ * 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, getI32Decoder, getI32Encoder, getStructDecoder, getStructEncoder, getU128Decoder, getU128Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+import { getBalanceDeltaDecoder, getBalanceDeltaEncoder, type BalanceDelta, type BalanceDeltaArgs } from './index.js';
+
+export type ActionResult = { index: number; kind: number; delta: BalanceDelta; fees0: bigint; fees1: bigint; postSqrtPriceX64: bigint; postTick: number;  };
+
+export type ActionResultArgs = { index: number; kind: number; delta: BalanceDeltaArgs; fees0: number | bigint; fees1: number | bigint; postSqrtPriceX64: number | bigint; postTick: number;  };
+
+export function getActionResultEncoder(): FixedSizeEncoder<ActionResultArgs> {
+    return getStructEncoder([['index', getU8Encoder()], ['kind', getU8Encoder()], ['delta', getBalanceDeltaEncoder()], ['fees0', getU64Encoder()], ['fees1', getU64Encoder()], ['postSqrtPriceX64', getU128Encoder()], ['postTick', getI32Encoder()]]);
+}
+
+export function getActionResultDecoder(): FixedSizeDecoder<ActionResult> {
+    return getStructDecoder([['index', getU8Decoder()], ['kind', getU8Decoder()], ['delta', getBalanceDeltaDecoder()], ['fees0', getU64Decoder()], ['fees1', getU64Decoder()], ['postSqrtPriceX64', getU128Decoder()], ['postTick', getI32Decoder()]]);
+}
+
+export function getActionResultCodec(): FixedSizeCodec<ActionResultArgs, ActionResult> {
+    return combineCodec(getActionResultEncoder(), getActionResultDecoder());
+}

package/src/generated/client/floor_hook/types/balanceDelta.ts

@@ -0,0 +1,25 @@
+/**
+ * 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, getI128Decoder, getI128Encoder, getStructDecoder, getStructEncoder, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type BalanceDelta = { amount0: bigint; amount1: bigint;  };
+
+export type BalanceDeltaArgs = { amount0: number | bigint; amount1: number | bigint;  };
+
+export function getBalanceDeltaEncoder(): FixedSizeEncoder<BalanceDeltaArgs> {
+    return getStructEncoder([['amount0', getI128Encoder()], ['amount1', getI128Encoder()]]);
+}
+
+export function getBalanceDeltaDecoder(): FixedSizeDecoder<BalanceDelta> {
+    return getStructDecoder([['amount0', getI128Decoder()], ['amount1', getI128Decoder()]]);
+}
+
+export function getBalanceDeltaCodec(): FixedSizeCodec<BalanceDeltaArgs, BalanceDelta> {
+    return combineCodec(getBalanceDeltaEncoder(), getBalanceDeltaDecoder());
+}

package/src/generated/client/floor_hook/types/hookAction.ts

@@ -0,0 +1,36 @@
+/**
+ * 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, getBooleanDecoder, getBooleanEncoder, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getI128Decoder, getI128Encoder, getI32Decoder, getI32Encoder, getStructDecoder, getStructEncoder, getU128Decoder, getU128Encoder, getU64Decoder, getU64Encoder, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type HookAction = { __kind: "ModifyPosition", salt: bigint; tickLower: number; tickUpper: number; liquidityDelta: bigint;  } | { __kind: "Swap", zeroForOne: boolean; amountSpecified: bigint; sqrtPriceLimitX64: bigint;  };
+
+export type HookActionArgs = { __kind: "ModifyPosition", salt: number | bigint; tickLower: number; tickUpper: number; liquidityDelta: number | bigint;  } | { __kind: "Swap", zeroForOne: boolean; amountSpecified: number | bigint; sqrtPriceLimitX64: number | bigint;  };
+
+export function getHookActionEncoder(): Encoder<HookActionArgs> {
+    return getDiscriminatedUnionEncoder([['ModifyPosition', getStructEncoder([['salt', getU64Encoder()], ['tickLower', getI32Encoder()], ['tickUpper', getI32Encoder()], ['liquidityDelta', getI128Encoder()]])], ['Swap', getStructEncoder([['zeroForOne', getBooleanEncoder()], ['amountSpecified', getI128Encoder()], ['sqrtPriceLimitX64', getU128Encoder()]])]]);
+}
+
+export function getHookActionDecoder(): Decoder<HookAction> {
+    return getDiscriminatedUnionDecoder([['ModifyPosition', getStructDecoder([['salt', getU64Decoder()], ['tickLower', getI32Decoder()], ['tickUpper', getI32Decoder()], ['liquidityDelta', getI128Decoder()]])], ['Swap', getStructDecoder([['zeroForOne', getBooleanDecoder()], ['amountSpecified', getI128Decoder()], ['sqrtPriceLimitX64', getU128Decoder()]])]]);
+}
+
+export function getHookActionCodec(): Codec<HookActionArgs, HookAction> {
+    return combineCodec(getHookActionEncoder(), getHookActionDecoder());
+}
+
+// Data Enum Helpers.
+export function hookAction(kind: 'ModifyPosition', data: GetDiscriminatedUnionVariantContent<HookActionArgs, '__kind', 'ModifyPosition'>): GetDiscriminatedUnionVariant<HookActionArgs, '__kind', 'ModifyPosition'>;
+export function hookAction(kind: 'Swap', data: GetDiscriminatedUnionVariantContent<HookActionArgs, '__kind', 'Swap'>): GetDiscriminatedUnionVariant<HookActionArgs, '__kind', 'Swap'>;
+export function hookAction<K extends HookActionArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isHookAction<K extends HookAction['__kind']>(kind: K, value: HookAction): value is HookAction & { __kind: K } {
+  return value.__kind === kind;
+};

package/src/generated/client/floor_hook/types/hookRecordV1.ts

@@ -0,0 +1,26 @@
+/**
+ * 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, getArrayDecoder, getArrayEncoder, getBooleanDecoder, getBooleanEncoder, getI128Decoder, getI128Encoder, getOptionDecoder, getOptionEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, type Codec, type Decoder, type Encoder, type Option, type OptionOrNullable } from '@solana/kit';
+import { getHookActionDecoder, getHookActionEncoder, type HookAction, type HookActionArgs } from './index.js';
+
+export type HookRecordV1 = { version: number; phase: number; round: number; wantCallback: boolean; feeOverridePips: Option<number>; deltaSpecified: bigint; deltaUnspecified: bigint; signals: number; fees: Array<bigint>; actions: Array<HookAction>;  };
+
+export type HookRecordV1Args = { version: number; phase: number; round: number; wantCallback: boolean; feeOverridePips: OptionOrNullable<number>; deltaSpecified: number | bigint; deltaUnspecified: number | bigint; signals: number; fees: Array<number | bigint>; actions: Array<HookActionArgs>;  };
+
+export function getHookRecordV1Encoder(): Encoder<HookRecordV1Args> {
+    return getStructEncoder([['version', getU8Encoder()], ['phase', getU8Encoder()], ['round', getU8Encoder()], ['wantCallback', getBooleanEncoder()], ['feeOverridePips', getOptionEncoder(getU32Encoder())], ['deltaSpecified', getI128Encoder()], ['deltaUnspecified', getI128Encoder()], ['signals', getU8Encoder()], ['fees', getArrayEncoder(getU64Encoder(), { size: 5 })], ['actions', getArrayEncoder(getHookActionEncoder())]]);
+}
+
+export function getHookRecordV1Decoder(): Decoder<HookRecordV1> {
+    return getStructDecoder([['version', getU8Decoder()], ['phase', getU8Decoder()], ['round', getU8Decoder()], ['wantCallback', getBooleanDecoder()], ['feeOverridePips', getOptionDecoder(getU32Decoder())], ['deltaSpecified', getI128Decoder()], ['deltaUnspecified', getI128Decoder()], ['signals', getU8Decoder()], ['fees', getArrayDecoder(getU64Decoder(), { size: 5 })], ['actions', getArrayDecoder(getHookActionDecoder())]]);
+}
+
+export function getHookRecordV1Codec(): Codec<HookRecordV1Args, HookRecordV1> {
+    return combineCodec(getHookRecordV1Encoder(), getHookRecordV1Decoder());
+}

package/src/generated/client/floor_hook/types/index.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 './actionResult.js';
+export * from './balanceDelta.js';
+export * from './hookAction.js';
+export * from './hookRecordV1.js';
+export * from './poolSnapshot.js';
+export * from './rentOwnerArg.js';
+export * from './slotArg.js';
+export * from './stairOwnerKindArg.js';
+export * from './swapParams.js';
+export * from './u128.js';

package/src/generated/client/floor_hook/types/poolSnapshot.ts

@@ -0,0 +1,25 @@
+/**
+ * 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, getI32Decoder, getI32Encoder, getStructDecoder, getStructEncoder, getU128Decoder, getU128Encoder, getU32Decoder, getU32Encoder, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type PoolSnapshot = { sqrtPriceX64: bigint; tick: number; liquidity: bigint; lpFeePips: number;  };
+
+export type PoolSnapshotArgs = { sqrtPriceX64: number | bigint; tick: number; liquidity: number | bigint; lpFeePips: number;  };
+
+export function getPoolSnapshotEncoder(): FixedSizeEncoder<PoolSnapshotArgs> {
+    return getStructEncoder([['sqrtPriceX64', getU128Encoder()], ['tick', getI32Encoder()], ['liquidity', getU128Encoder()], ['lpFeePips', getU32Encoder()]]);
+}
+
+export function getPoolSnapshotDecoder(): FixedSizeDecoder<PoolSnapshot> {
+    return getStructDecoder([['sqrtPriceX64', getU128Decoder()], ['tick', getI32Decoder()], ['liquidity', getU128Decoder()], ['lpFeePips', getU32Decoder()]]);
+}
+
+export function getPoolSnapshotCodec(): FixedSizeCodec<PoolSnapshotArgs, PoolSnapshot> {
+    return combineCodec(getPoolSnapshotEncoder(), getPoolSnapshotDecoder());
+}

package/src/generated/client/floor_hook/types/rentOwnerArg.ts

@@ -0,0 +1,25 @@
+/**
+ * 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, getAddressDecoder, getAddressEncoder, getStructDecoder, getStructEncoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type RentOwnerArg = { rentOwner: Address;  };
+
+export type RentOwnerArgArgs = RentOwnerArg;
+
+export function getRentOwnerArgEncoder(): FixedSizeEncoder<RentOwnerArgArgs> {
+    return getStructEncoder([['rentOwner', getAddressEncoder()]]);
+}
+
+export function getRentOwnerArgDecoder(): FixedSizeDecoder<RentOwnerArg> {
+    return getStructDecoder([['rentOwner', getAddressDecoder()]]);
+}
+
+export function getRentOwnerArgCodec(): FixedSizeCodec<RentOwnerArgArgs, RentOwnerArg> {
+    return combineCodec(getRentOwnerArgEncoder(), getRentOwnerArgDecoder());
+}

package/src/generated/client/floor_hook/types/slotArg.ts

@@ -0,0 +1,25 @@
+/**
+ * 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, getU16Decoder, getU16Encoder, getU8Decoder, getU8Encoder, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+
+export type SlotArg = { bps: number; platform: number; key: ReadonlyUint8Array;  };
+
+export type SlotArgArgs = SlotArg;
+
+export function getSlotArgEncoder(): FixedSizeEncoder<SlotArgArgs> {
+    return getStructEncoder([['bps', getU16Encoder()], ['platform', getU8Encoder()], ['key', fixEncoderSize(getBytesEncoder(), 32)]]);
+}
+
+export function getSlotArgDecoder(): FixedSizeDecoder<SlotArg> {
+    return getStructDecoder([['bps', getU16Decoder()], ['platform', getU8Decoder()], ['key', fixDecoderSize(getBytesDecoder(), 32)]]);
+}
+
+export function getSlotArgCodec(): FixedSizeCodec<SlotArgArgs, SlotArg> {
+    return combineCodec(getSlotArgEncoder(), getSlotArgDecoder());
+}