@shogun-sdk/intents-sdk 1.2.1 → 1.2.2

package/src/core/solana/generated/single-chain/programs/singleChainGuard.ts

@@ -6,8 +6,13 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { type Address } from '@solana/kit';
-import { containsBytes, fixEncoderSize, getBytesEncoder, type ReadonlyUint8Array } from '@solana/kit';
+import { type Address } from '@solana/addresses';
+import {
+  containsBytes,
+  fixEncoderSize,
+  getBytesEncoder,
+  type ReadonlyUint8Array,
+} from '@solana/codecs';
 import {
   type ParsedAcceptAdminInstruction,
   type ParsedCancelDcaOrderInstruction,
@@ -34,14 +39,16 @@ export enum SingleChainGuardAccount {
 }
 
 export function identifySingleChainGuardAccount(
-  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array
 ): SingleChainGuardAccount {
   const data = 'data' in account ? account.data : account;
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194])
+      ),
+      0
     )
   ) {
     return SingleChainGuardAccount.AdminSingleton;
@@ -49,8 +56,10 @@ export function identifySingleChainGuardAccount(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([55, 1, 103, 253, 215, 66, 27, 57])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([55, 1, 103, 253, 215, 66, 27, 57])
+      ),
+      0
     )
   ) {
     return SingleChainGuardAccount.DcaOrder;
@@ -58,8 +67,10 @@ export function identifySingleChainGuardAccount(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248])
+      ),
+      0
     )
   ) {
     return SingleChainGuardAccount.Guard;
@@ -67,8 +78,10 @@ export function identifySingleChainGuardAccount(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([137, 183, 212, 91, 115, 29, 141, 227])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([137, 183, 212, 91, 115, 29, 141, 227])
+      ),
+      0
     )
   ) {
     return SingleChainGuardAccount.LimitOrder;
@@ -92,14 +105,16 @@ export enum SingleChainGuardInstruction {
 }
 
 export function identifySingleChainGuardInstruction(
-  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array
 ): SingleChainGuardInstruction {
   const data = 'data' in instruction ? instruction.data : instruction;
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([112, 42, 45, 90, 116, 181, 13, 170])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([112, 42, 45, 90, 116, 181, 13, 170])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.AcceptAdmin;
@@ -107,8 +122,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([60, 161, 130, 157, 181, 55, 218, 163])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([60, 161, 130, 157, 181, 55, 218, 163])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CancelDcaOrder;
@@ -116,8 +133,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([132, 156, 132, 31, 67, 40, 232, 97])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([132, 156, 132, 31, 67, 40, 232, 97])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CancelLimitOrder;
@@ -125,8 +144,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([22, 67, 23, 98, 150, 178, 70, 220])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([22, 67, 23, 98, 150, 178, 70, 220])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CollectProtocolFees;
@@ -134,8 +155,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([95, 66, 166, 38, 170, 3, 150, 169])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([95, 66, 166, 38, 170, 3, 150, 169])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CreateDcaOrder;
@@ -143,8 +166,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([251, 254, 17, 198, 219, 218, 154, 99])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([251, 254, 17, 198, 219, 218, 154, 99])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CreateGuard;
@@ -152,8 +177,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([76, 161, 70, 122, 82, 20, 142, 75])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([76, 161, 70, 122, 82, 20, 142, 75])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.CreateLimitOrder;
@@ -161,8 +188,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([15, 118, 183, 60, 46, 43, 243, 244])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([15, 118, 183, 60, 46, 43, 243, 244])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.FulfillDcaOrderInterval;
@@ -170,8 +199,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([70, 1, 151, 197, 125, 110, 46, 244])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([70, 1, 151, 197, 125, 110, 46, 244])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.FulfillLimitOrder;
@@ -179,8 +210,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([175, 175, 109, 31, 13, 152, 155, 237])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([175, 175, 109, 31, 13, 152, 155, 237])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.Initialize;
@@ -188,8 +221,10 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([251, 163, 0, 52, 91, 194, 187, 92])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([251, 163, 0, 52, 91, 194, 187, 92])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.SetAdmin;
@@ -197,13 +232,17 @@ export function identifySingleChainGuardInstruction(
   if (
     containsBytes(
       data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([153, 39, 10, 108, 220, 0, 84, 47])),
-      0,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([153, 39, 10, 108, 220, 0, 84, 47])
+      ),
+      0
     )
   ) {
     return SingleChainGuardInstruction.SetAuctioneerPubKey;
   }
-  throw new Error('The provided instruction could not be identified as a singleChainGuard instruction.');
+  throw new Error(
+    'The provided instruction could not be identified as a singleChainGuard instruction.'
+  );
 }
 
 export type ParsedSingleChainGuardInstruction<

package/src/core/solana/generated/single-chain/shared/index.ts

@@ -6,20 +6,24 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { isProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
-import { AccountRole, type IAccountMeta, upgradeRoleToSigner } from '@solana/kit';
+import {
+  isProgramDerivedAddress,
+  type Address,
+  type ProgramDerivedAddress,
+} from '@solana/addresses';
+import { AccountRole, type AccountMeta, upgradeRoleToSigner } from '@solana/instructions';
 import {
   isTransactionSigner as kitIsTransactionSigner,
-  type IAccountSignerMeta,
+  type AccountSignerMeta,
   type TransactionSigner,
-} from '@solana/kit';
+} from '@solana/signers';
 
 /**
  * Asserts that the given value is not null or undefined.
  * @internal
  */
 export function expectSome<T>(value: T | null | undefined): T {
-  if (value == null) {
+  if (value === null || value === undefined) {
     throw new Error('Expected a value but received null or undefined.');
   }
   return value;
@@ -30,7 +34,7 @@ export function expectSome<T>(value: T | null | undefined): T {
  * @internal
  */
 export function expectAddress<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
 ): Address<T> {
   if (!value) {
     throw new Error('Expected a Address.');
@@ -39,7 +43,7 @@ export function expectAddress<T extends string = string>(
     return value.address;
   }
   if (Array.isArray(value)) {
-    return value[0];
+    return value[0] as Address<T>;
   }
   return value as Address<T>;
 }
@@ -49,7 +53,7 @@ export function expectAddress<T extends string = string>(
  * @internal
  */
 export function expectProgramDerivedAddress<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
 ): ProgramDerivedAddress<T> {
   if (!value || !Array.isArray(value) || !isProgramDerivedAddress(value)) {
     throw new Error('Expected a ProgramDerivedAddress.');
@@ -62,7 +66,7 @@ export function expectProgramDerivedAddress<T extends string = string>(
  * @internal
  */
 export function expectTransactionSigner<T extends string = string>(
-  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined
 ): TransactionSigner<T> {
   if (!value || !isTransactionSigner(value)) {
     throw new Error('Expected a TransactionSigner.');
@@ -90,7 +94,7 @@ export type ResolvedAccount<
  * Defines an instruction that stores additional bytes on-chain.
  * @internal
  */
-export type IInstructionWithByteDelta = {
+export type InstructionWithByteDelta = {
   byteDelta: number;
 };
 
@@ -98,8 +102,11 @@ export type IInstructionWithByteDelta = {
  * Get account metas and signers from resolved accounts.
  * @internal
  */
-export function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId') {
-  return (account: ResolvedAccount): IAccountMeta | IAccountSignerMeta | undefined => {
+export function getAccountMetaFactory(
+  programAddress: Address,
+  optionalAccountStrategy: 'omitted' | 'programId'
+) {
+  return (account: ResolvedAccount): AccountMeta | AccountSignerMeta | undefined => {
     if (!account.value) {
       if (optionalAccountStrategy === 'omitted') return;
       return Object.freeze({ address: programAddress, role: AccountRole.READONLY });
@@ -115,7 +122,9 @@ export function getAccountMetaFactory(programAddress: Address, optionalAccountSt
 }
 
 export function isTransactionSigner<TAddress extends string = string>(
-  value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>,
+  value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>
 ): value is TransactionSigner<TAddress> {
-  return !!value && typeof value === 'object' && 'address' in value && kitIsTransactionSigner(value);
+  return (
+    !!value && typeof value === 'object' && 'address' in value && kitIsTransactionSigner(value)
+  );
 }

package/src/core/solana/generated/single-chain/types/adminUpdateStarted.ts

@@ -13,23 +13,26 @@ import {
   getStructDecoder,
   getStructEncoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type AdminUpdateStarted = { newAdmin: Address };
 
 export type AdminUpdateStartedArgs = AdminUpdateStarted;
 
-export function getAdminUpdateStartedEncoder(): Encoder<AdminUpdateStartedArgs> {
+export function getAdminUpdateStartedEncoder(): FixedSizeEncoder<AdminUpdateStartedArgs> {
   return getStructEncoder([['newAdmin', getAddressEncoder()]]);
 }
 
-export function getAdminUpdateStartedDecoder(): Decoder<AdminUpdateStarted> {
+export function getAdminUpdateStartedDecoder(): FixedSizeDecoder<AdminUpdateStarted> {
   return getStructDecoder([['newAdmin', getAddressDecoder()]]);
 }
 
-export function getAdminUpdateStartedCodec(): Codec<AdminUpdateStartedArgs, AdminUpdateStarted> {
+export function getAdminUpdateStartedCodec(): FixedSizeCodec<
+  AdminUpdateStartedArgs,
+  AdminUpdateStarted
+> {
   return combineCodec(getAdminUpdateStartedEncoder(), getAdminUpdateStartedDecoder());
 }

package/src/core/solana/generated/single-chain/types/adminUpdated.ts

@@ -13,23 +13,23 @@ import {
   getStructDecoder,
   getStructEncoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type AdminUpdated = { newAdmin: Address };
 
 export type AdminUpdatedArgs = AdminUpdated;
 
-export function getAdminUpdatedEncoder(): Encoder<AdminUpdatedArgs> {
+export function getAdminUpdatedEncoder(): FixedSizeEncoder<AdminUpdatedArgs> {
   return getStructEncoder([['newAdmin', getAddressEncoder()]]);
 }
 
-export function getAdminUpdatedDecoder(): Decoder<AdminUpdated> {
+export function getAdminUpdatedDecoder(): FixedSizeDecoder<AdminUpdated> {
   return getStructDecoder([['newAdmin', getAddressDecoder()]]);
 }
 
-export function getAdminUpdatedCodec(): Codec<AdminUpdatedArgs, AdminUpdated> {
+export function getAdminUpdatedCodec(): FixedSizeCodec<AdminUpdatedArgs, AdminUpdated> {
   return combineCodec(getAdminUpdatedEncoder(), getAdminUpdatedDecoder());
 }

package/src/core/solana/generated/single-chain/types/auctioneerPubkeyUpdated.ts

@@ -13,29 +13,32 @@ import {
   getStructDecoder,
   getStructEncoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type AuctioneerPubkeyUpdated = { guardId: Address; auctioneerPubKey: Address };
 
 export type AuctioneerPubkeyUpdatedArgs = AuctioneerPubkeyUpdated;
 
-export function getAuctioneerPubkeyUpdatedEncoder(): Encoder<AuctioneerPubkeyUpdatedArgs> {
+export function getAuctioneerPubkeyUpdatedEncoder(): FixedSizeEncoder<AuctioneerPubkeyUpdatedArgs> {
   return getStructEncoder([
     ['guardId', getAddressEncoder()],
     ['auctioneerPubKey', getAddressEncoder()],
   ]);
 }
 
-export function getAuctioneerPubkeyUpdatedDecoder(): Decoder<AuctioneerPubkeyUpdated> {
+export function getAuctioneerPubkeyUpdatedDecoder(): FixedSizeDecoder<AuctioneerPubkeyUpdated> {
   return getStructDecoder([
     ['guardId', getAddressDecoder()],
     ['auctioneerPubKey', getAddressDecoder()],
   ]);
 }
 
-export function getAuctioneerPubkeyUpdatedCodec(): Codec<AuctioneerPubkeyUpdatedArgs, AuctioneerPubkeyUpdated> {
+export function getAuctioneerPubkeyUpdatedCodec(): FixedSizeCodec<
+  AuctioneerPubkeyUpdatedArgs,
+  AuctioneerPubkeyUpdated
+> {
   return combineCodec(getAuctioneerPubkeyUpdatedEncoder(), getAuctioneerPubkeyUpdatedDecoder());
 }

package/src/core/solana/generated/single-chain/types/dcaOrderCreated.ts

@@ -19,9 +19,9 @@ import {
   getU8Decoder,
   getU8Encoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type DcaOrderCreated = {
@@ -52,7 +52,7 @@ export type DcaOrderCreatedArgs = {
   intervalDuration: number;
 };
 
-export function getDcaOrderCreatedEncoder(): Encoder<DcaOrderCreatedArgs> {
+export function getDcaOrderCreatedEncoder(): FixedSizeEncoder<DcaOrderCreatedArgs> {
   return getStructEncoder([
     ['orderId', getAddressEncoder()],
     ['user', getAddressEncoder()],
@@ -68,7 +68,7 @@ export function getDcaOrderCreatedEncoder(): Encoder<DcaOrderCreatedArgs> {
   ]);
 }
 
-export function getDcaOrderCreatedDecoder(): Decoder<DcaOrderCreated> {
+export function getDcaOrderCreatedDecoder(): FixedSizeDecoder<DcaOrderCreated> {
   return getStructDecoder([
     ['orderId', getAddressDecoder()],
     ['user', getAddressDecoder()],
@@ -84,6 +84,6 @@ export function getDcaOrderCreatedDecoder(): Decoder<DcaOrderCreated> {
   ]);
 }
 
-export function getDcaOrderCreatedCodec(): Codec<DcaOrderCreatedArgs, DcaOrderCreated> {
+export function getDcaOrderCreatedCodec(): FixedSizeCodec<DcaOrderCreatedArgs, DcaOrderCreated> {
   return combineCodec(getDcaOrderCreatedEncoder(), getDcaOrderCreatedDecoder());
 }

package/src/core/solana/generated/single-chain/types/dcaOrderFulfilled.ts

@@ -13,23 +13,26 @@ import {
   getStructDecoder,
   getStructEncoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type DcaOrderFulfilled = { orderId: Address };
 
 export type DcaOrderFulfilledArgs = DcaOrderFulfilled;
 
-export function getDcaOrderFulfilledEncoder(): Encoder<DcaOrderFulfilledArgs> {
+export function getDcaOrderFulfilledEncoder(): FixedSizeEncoder<DcaOrderFulfilledArgs> {
   return getStructEncoder([['orderId', getAddressEncoder()]]);
 }
 
-export function getDcaOrderFulfilledDecoder(): Decoder<DcaOrderFulfilled> {
+export function getDcaOrderFulfilledDecoder(): FixedSizeDecoder<DcaOrderFulfilled> {
   return getStructDecoder([['orderId', getAddressDecoder()]]);
 }
 
-export function getDcaOrderFulfilledCodec(): Codec<DcaOrderFulfilledArgs, DcaOrderFulfilled> {
+export function getDcaOrderFulfilledCodec(): FixedSizeCodec<
+  DcaOrderFulfilledArgs,
+  DcaOrderFulfilled
+> {
   return combineCodec(getDcaOrderFulfilledEncoder(), getDcaOrderFulfilledDecoder());
 }

package/src/core/solana/generated/single-chain/types/dcaOrderIntervalFulfilled.ts

@@ -17,9 +17,9 @@ import {
   getU64Decoder,
   getU64Encoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type DcaOrderIntervalFulfilled = {
@@ -38,7 +38,7 @@ export type DcaOrderIntervalFulfilledArgs = {
   intervalIndex: number;
 };
 
-export function getDcaOrderIntervalFulfilledEncoder(): Encoder<DcaOrderIntervalFulfilledArgs> {
+export function getDcaOrderIntervalFulfilledEncoder(): FixedSizeEncoder<DcaOrderIntervalFulfilledArgs> {
   return getStructEncoder([
     ['orderId', getAddressEncoder()],
     ['solver', getAddressEncoder()],
@@ -48,7 +48,7 @@ export function getDcaOrderIntervalFulfilledEncoder(): Encoder<DcaOrderIntervalF
   ]);
 }
 
-export function getDcaOrderIntervalFulfilledDecoder(): Decoder<DcaOrderIntervalFulfilled> {
+export function getDcaOrderIntervalFulfilledDecoder(): FixedSizeDecoder<DcaOrderIntervalFulfilled> {
   return getStructDecoder([
     ['orderId', getAddressDecoder()],
     ['solver', getAddressDecoder()],
@@ -58,6 +58,9 @@ export function getDcaOrderIntervalFulfilledDecoder(): Decoder<DcaOrderIntervalF
   ]);
 }
 
-export function getDcaOrderIntervalFulfilledCodec(): Codec<DcaOrderIntervalFulfilledArgs, DcaOrderIntervalFulfilled> {
+export function getDcaOrderIntervalFulfilledCodec(): FixedSizeCodec<
+  DcaOrderIntervalFulfilledArgs,
+  DcaOrderIntervalFulfilled
+> {
   return combineCodec(getDcaOrderIntervalFulfilledEncoder(), getDcaOrderIntervalFulfilledDecoder());
 }

package/src/core/solana/generated/single-chain/types/guardCreated.ts

@@ -13,16 +13,16 @@ import {
   getStructDecoder,
   getStructEncoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type GuardCreated = { guardId: Address; feeTokenMint: Address; auctioneerPubKey: Address };
 
 export type GuardCreatedArgs = GuardCreated;
 
-export function getGuardCreatedEncoder(): Encoder<GuardCreatedArgs> {
+export function getGuardCreatedEncoder(): FixedSizeEncoder<GuardCreatedArgs> {
   return getStructEncoder([
     ['guardId', getAddressEncoder()],
     ['feeTokenMint', getAddressEncoder()],
@@ -30,7 +30,7 @@ export function getGuardCreatedEncoder(): Encoder<GuardCreatedArgs> {
   ]);
 }
 
-export function getGuardCreatedDecoder(): Decoder<GuardCreated> {
+export function getGuardCreatedDecoder(): FixedSizeDecoder<GuardCreated> {
   return getStructDecoder([
     ['guardId', getAddressDecoder()],
     ['feeTokenMint', getAddressDecoder()],
@@ -38,6 +38,6 @@ export function getGuardCreatedDecoder(): Decoder<GuardCreated> {
   ]);
 }
 
-export function getGuardCreatedCodec(): Codec<GuardCreatedArgs, GuardCreated> {
+export function getGuardCreatedCodec(): FixedSizeCodec<GuardCreatedArgs, GuardCreated> {
   return combineCodec(getGuardCreatedEncoder(), getGuardCreatedDecoder());
 }

package/src/core/solana/generated/single-chain/types/limitOrderCreated.ts

@@ -19,9 +19,9 @@ import {
   getU8Decoder,
   getU8Encoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type LimitOrderCreated = {
@@ -46,7 +46,7 @@ export type LimitOrderCreatedArgs = {
   deadline: number;
 };
 
-export function getLimitOrderCreatedEncoder(): Encoder<LimitOrderCreatedArgs> {
+export function getLimitOrderCreatedEncoder(): FixedSizeEncoder<LimitOrderCreatedArgs> {
   return getStructEncoder([
     ['orderId', getAddressEncoder()],
     ['user', getAddressEncoder()],
@@ -59,7 +59,7 @@ export function getLimitOrderCreatedEncoder(): Encoder<LimitOrderCreatedArgs> {
   ]);
 }
 
-export function getLimitOrderCreatedDecoder(): Decoder<LimitOrderCreated> {
+export function getLimitOrderCreatedDecoder(): FixedSizeDecoder<LimitOrderCreated> {
   return getStructDecoder([
     ['orderId', getAddressDecoder()],
     ['user', getAddressDecoder()],
@@ -72,6 +72,9 @@ export function getLimitOrderCreatedDecoder(): Decoder<LimitOrderCreated> {
   ]);
 }
 
-export function getLimitOrderCreatedCodec(): Codec<LimitOrderCreatedArgs, LimitOrderCreated> {
+export function getLimitOrderCreatedCodec(): FixedSizeCodec<
+  LimitOrderCreatedArgs,
+  LimitOrderCreated
+> {
   return combineCodec(getLimitOrderCreatedEncoder(), getLimitOrderCreatedDecoder());
 }

package/src/core/solana/generated/single-chain/types/limitOrderFulfilled.ts

@@ -15,29 +15,32 @@ import {
   getU64Decoder,
   getU64Encoder,
   type Address,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
 } from '@solana/kit';
 
 export type LimitOrderFulfilled = { orderId: Address; mainAmountOut: bigint };
 
 export type LimitOrderFulfilledArgs = { orderId: Address; mainAmountOut: number | bigint };
 
-export function getLimitOrderFulfilledEncoder(): Encoder<LimitOrderFulfilledArgs> {
+export function getLimitOrderFulfilledEncoder(): FixedSizeEncoder<LimitOrderFulfilledArgs> {
   return getStructEncoder([
     ['orderId', getAddressEncoder()],
     ['mainAmountOut', getU64Encoder()],
   ]);
 }
 
-export function getLimitOrderFulfilledDecoder(): Decoder<LimitOrderFulfilled> {
+export function getLimitOrderFulfilledDecoder(): FixedSizeDecoder<LimitOrderFulfilled> {
   return getStructDecoder([
     ['orderId', getAddressDecoder()],
     ['mainAmountOut', getU64Decoder()],
   ]);
 }
 
-export function getLimitOrderFulfilledCodec(): Codec<LimitOrderFulfilledArgs, LimitOrderFulfilled> {
+export function getLimitOrderFulfilledCodec(): FixedSizeCodec<
+  LimitOrderFulfilledArgs,
+  LimitOrderFulfilled
+> {
   return combineCodec(getLimitOrderFulfilledEncoder(), getLimitOrderFulfilledDecoder());
 }