@shogun-sdk/intents-sdk 1.2.1 → 1.2.3

package/src/core/solana/dca/single-chain-limit-order.ts

@@ -0,0 +1,45 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { keccak256 } from "js-sha3";
+
+export type ExtraTransfer = {
+  token: PublicKey;
+  receiver: PublicKey;
+  amount: string;
+};
+
+/**
+ * Generate secret number and prepare secret hash for single chain limit orders
+ * @param tokenOut Token OUT Pubkey
+ * @param receiver Token OUT receiver Pubkey
+ * @param extraTransfers Requested extra transfers
+ */
+export function prepareSecretData(
+  tokenOut: PublicKey,
+  receiver: PublicKey,
+  extraTransfers: ExtraTransfer[],
+) {
+  const secretNumber = new BN(crypto.getRandomValues(new Uint8Array(8)));
+  const secretHash = [...Uint8Array.from(Buffer.from(
+    keccak256([
+      ...tokenOut.toBuffer(),
+      ...receiver.toBuffer(),
+      ...Buffer.concat(extraTransfers.map(t => Buffer.concat([
+        t.token.toBuffer(),
+        t.receiver.toBuffer(),
+      ]))),
+      ...secretNumber.toBuffer('le', 8),
+    ]),
+    'hex'
+  ))];
+
+  return { secretHash, secretNumber };
+}
+
+export function formatTokenPubkey(token: PublicKey) {
+  if (token.equals(new PublicKey("So11111111111111111111111111111111111111111"))) {
+    return PublicKey.default
+  }
+
+  return token;
+}

package/src/core/solana/generated/cross-chain/accounts/adminSingleton.ts

@@ -18,8 +18,8 @@ import {
   type FetchAccountsConfig,
   type MaybeAccount,
   type MaybeEncodedAccount,
-} from '@solana/kit';
-import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+} from '@solana/accounts';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/addresses';
 import {
   combineCodec,
   fixDecoderSize,
@@ -31,13 +31,15 @@ import {
   getU8Decoder,
   getU8Encoder,
   transformEncoder,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
   type ReadonlyUint8Array,
-} from '@solana/kit';
+} from '@solana/codecs';
 
-export const ADMIN_SINGLETON_DISCRIMINATOR = new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194]);
+export const ADMIN_SINGLETON_DISCRIMINATOR = new Uint8Array([
+  179, 22, 254, 245, 204, 230, 222, 194,
+]);
 
 export function getAdminSingletonDiscriminatorBytes() {
   return fixEncoderSize(getBytesEncoder(), 8).encode(ADMIN_SINGLETON_DISCRIMINATOR);
@@ -62,7 +64,7 @@ export type AdminSingletonArgs = {
   bump: number;
 };
 
-export function getAdminSingletonEncoder(): Encoder<AdminSingletonArgs> {
+export function getAdminSingletonEncoder(): FixedSizeEncoder<AdminSingletonArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
@@ -70,11 +72,11 @@ export function getAdminSingletonEncoder(): Encoder<AdminSingletonArgs> {
       ['pendingAdmin', getAddressEncoder()],
       ['bump', getU8Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR }),
+    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR })
   );
 }
 
-export function getAdminSingletonDecoder(): Decoder<AdminSingleton> {
+export function getAdminSingletonDecoder(): FixedSizeDecoder<AdminSingleton> {
   return getStructDecoder([
     ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
     ['admin', getAddressDecoder()],
@@ -83,18 +85,18 @@ export function getAdminSingletonDecoder(): Decoder<AdminSingleton> {
   ]);
 }
 
-export function getAdminSingletonCodec(): Codec<AdminSingletonArgs, AdminSingleton> {
+export function getAdminSingletonCodec(): FixedSizeCodec<AdminSingletonArgs, AdminSingleton> {
   return combineCodec(getAdminSingletonEncoder(), getAdminSingletonDecoder());
 }
 
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress>
 ): Account<AdminSingleton, TAddress>;
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>,
+  encodedAccount: MaybeEncodedAccount<TAddress>
 ): MaybeAccount<AdminSingleton, TAddress>;
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
 ): Account<AdminSingleton, TAddress> | MaybeAccount<AdminSingleton, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getAdminSingletonDecoder());
 }
@@ -102,7 +104,7 @@ export function decodeAdminSingleton<TAddress extends string = string>(
 export async function fetchAdminSingleton<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<Account<AdminSingleton, TAddress>> {
   const maybeAccount = await fetchMaybeAdminSingleton(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -112,7 +114,7 @@ export async function fetchAdminSingleton<TAddress extends string = string>(
 export async function fetchMaybeAdminSingleton<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<MaybeAccount<AdminSingleton, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeAdminSingleton(maybeAccount);
@@ -121,7 +123,7 @@ export async function fetchMaybeAdminSingleton<TAddress extends string = string>
 export async function fetchAllAdminSingleton(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<Account<AdminSingleton>[]> {
   const maybeAccounts = await fetchAllMaybeAdminSingleton(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -131,7 +133,7 @@ export async function fetchAllAdminSingleton(
 export async function fetchAllMaybeAdminSingleton(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<MaybeAccount<AdminSingleton>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAdminSingleton(maybeAccount));

package/src/core/solana/generated/cross-chain/accounts/dcaOrder.ts

@@ -0,0 +1,248 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/accounts';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/addresses';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBooleanDecoder,
+  getBooleanEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  transformEncoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type ReadonlyUint8Array,
+} from '@solana/codecs';
+
+export const DCA_ORDER_DISCRIMINATOR = new Uint8Array([55, 1, 103, 253, 215, 66, 27, 57]);
+
+export function getDcaOrderDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(DCA_ORDER_DISCRIMINATOR);
+}
+
+export type DcaOrder = {
+  discriminator: ReadonlyUint8Array;
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens IN user is willing to spend per interval/trade */
+  amountInPerInterval: bigint;
+  /** Min amount of stablecoins to receive if token IN will be swapped */
+  minStablecoinsAmountPerInterval: bigint;
+  /** Timestamp (in seconds) when the user created and submitted the DCA order */
+  startTime: number;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+  /** Total number of intervals over which the DCA order will be executed */
+  totalIntervals: number;
+  /** DCA interval duration, in seconds */
+  intervalDuration: number;
+  /** 32 bytes SHA-256 hash of execution details JSON string. Everything that's not used in smart contract */
+  executionDetailsHash: ReadonlyUint8Array;
+  /** True if order was cancelled while execution was in progress */
+  cancelled: boolean;
+  /** `true` if tokens IN were taken for swap during `pre_swap` instruction */
+  tokensInWereSwapped: boolean;
+  /** Amount of stablecoins, locked after swap */
+  lockedStablecoins: bigint;
+  /** Collateral amount, locked during order execution */
+  lockedCollateral: bigint;
+  /** Active solver which is currently executing this order */
+  activeSolver: Address;
+  /**
+   * Timestamp, until which `active_solver` MUST execute the order and claim tokens
+   * Order is locked for everyone but `active_solver` until this deadline
+   */
+  executionDeadline: number;
+  /** Interval INDEX when latest order execution has started */
+  intervalIndexOfLatestExecutionStart: number;
+  /** Total number of already executed intervals */
+  totalExecutedIntervals: number;
+  /** INDEX of last executed interval */
+  lastExecutedIntervalIndex: number;
+};
+
+export type DcaOrderArgs = {
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens IN user is willing to spend per interval/trade */
+  amountInPerInterval: number | bigint;
+  /** Min amount of stablecoins to receive if token IN will be swapped */
+  minStablecoinsAmountPerInterval: number | bigint;
+  /** Timestamp (in seconds) when the user created and submitted the DCA order */
+  startTime: number;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+  /** Total number of intervals over which the DCA order will be executed */
+  totalIntervals: number;
+  /** DCA interval duration, in seconds */
+  intervalDuration: number;
+  /** 32 bytes SHA-256 hash of execution details JSON string. Everything that's not used in smart contract */
+  executionDetailsHash: ReadonlyUint8Array;
+  /** True if order was cancelled while execution was in progress */
+  cancelled: boolean;
+  /** `true` if tokens IN were taken for swap during `pre_swap` instruction */
+  tokensInWereSwapped: boolean;
+  /** Amount of stablecoins, locked after swap */
+  lockedStablecoins: number | bigint;
+  /** Collateral amount, locked during order execution */
+  lockedCollateral: number | bigint;
+  /** Active solver which is currently executing this order */
+  activeSolver: Address;
+  /**
+   * Timestamp, until which `active_solver` MUST execute the order and claim tokens
+   * Order is locked for everyone but `active_solver` until this deadline
+   */
+  executionDeadline: number;
+  /** Interval INDEX when latest order execution has started */
+  intervalIndexOfLatestExecutionStart: number;
+  /** Total number of already executed intervals */
+  totalExecutedIntervals: number;
+  /** INDEX of last executed interval */
+  lastExecutedIntervalIndex: number;
+};
+
+export function getDcaOrderEncoder(): FixedSizeEncoder<DcaOrderArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['user', getAddressEncoder()],
+      ['guard', getAddressEncoder()],
+      ['tokenInMint', getAddressEncoder()],
+      ['amountInPerInterval', getU64Encoder()],
+      ['minStablecoinsAmountPerInterval', getU64Encoder()],
+      ['startTime', getU32Encoder()],
+      ['deadline', getU32Encoder()],
+      ['totalIntervals', getU32Encoder()],
+      ['intervalDuration', getU32Encoder()],
+      ['executionDetailsHash', fixEncoderSize(getBytesEncoder(), 32)],
+      ['cancelled', getBooleanEncoder()],
+      ['tokensInWereSwapped', getBooleanEncoder()],
+      ['lockedStablecoins', getU64Encoder()],
+      ['lockedCollateral', getU64Encoder()],
+      ['activeSolver', getAddressEncoder()],
+      ['executionDeadline', getU32Encoder()],
+      ['intervalIndexOfLatestExecutionStart', getU32Encoder()],
+      ['totalExecutedIntervals', getU32Encoder()],
+      ['lastExecutedIntervalIndex', getU32Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: DCA_ORDER_DISCRIMINATOR })
+  );
+}
+
+export function getDcaOrderDecoder(): FixedSizeDecoder<DcaOrder> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['user', getAddressDecoder()],
+    ['guard', getAddressDecoder()],
+    ['tokenInMint', getAddressDecoder()],
+    ['amountInPerInterval', getU64Decoder()],
+    ['minStablecoinsAmountPerInterval', getU64Decoder()],
+    ['startTime', getU32Decoder()],
+    ['deadline', getU32Decoder()],
+    ['totalIntervals', getU32Decoder()],
+    ['intervalDuration', getU32Decoder()],
+    ['executionDetailsHash', fixDecoderSize(getBytesDecoder(), 32)],
+    ['cancelled', getBooleanDecoder()],
+    ['tokensInWereSwapped', getBooleanDecoder()],
+    ['lockedStablecoins', getU64Decoder()],
+    ['lockedCollateral', getU64Decoder()],
+    ['activeSolver', getAddressDecoder()],
+    ['executionDeadline', getU32Decoder()],
+    ['intervalIndexOfLatestExecutionStart', getU32Decoder()],
+    ['totalExecutedIntervals', getU32Decoder()],
+    ['lastExecutedIntervalIndex', getU32Decoder()],
+  ]);
+}
+
+export function getDcaOrderCodec(): FixedSizeCodec<DcaOrderArgs, DcaOrder> {
+  return combineCodec(getDcaOrderEncoder(), getDcaOrderDecoder());
+}
+
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>
+): Account<DcaOrder, TAddress>;
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>
+): MaybeAccount<DcaOrder, TAddress>;
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
+): Account<DcaOrder, TAddress> | MaybeAccount<DcaOrder, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getDcaOrderDecoder());
+}
+
+export async function fetchDcaOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig
+): Promise<Account<DcaOrder, TAddress>> {
+  const maybeAccount = await fetchMaybeDcaOrder(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeDcaOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig
+): Promise<MaybeAccount<DcaOrder, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeDcaOrder(maybeAccount);
+}
+
+export async function fetchAllDcaOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig
+): Promise<Account<DcaOrder>[]> {
+  const maybeAccounts = await fetchAllMaybeDcaOrder(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeDcaOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig
+): Promise<MaybeAccount<DcaOrder>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeDcaOrder(maybeAccount));
+}
+
+export function getDcaOrderSize(): number {
+  return 234;
+}

package/src/core/solana/generated/cross-chain/accounts/guard.ts

@@ -18,8 +18,8 @@ import {
   type FetchAccountsConfig,
   type MaybeAccount,
   type MaybeEncodedAccount,
-} from '@solana/kit';
-import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+} from '@solana/accounts';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/addresses';
 import {
   combineCodec,
   fixDecoderSize,
@@ -33,11 +33,11 @@ import {
   getU8Decoder,
   getU8Encoder,
   transformEncoder,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
   type ReadonlyUint8Array,
-} from '@solana/kit';
+} from '@solana/codecs';
 
 export const GUARD_DISCRIMINATOR = new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248]);
 
@@ -51,6 +51,8 @@ export type Guard = {
   collateralToken: Address;
   /** Token that is used as token OUT when swapping Token IN during order execution start */
   stablecoinToken: Address;
+  /** Version that allows having multiple Guards with same `collateral_token` + `stablecoin_token` */
+  version: number;
   /** PDA bump */
   bump: number;
   /** Public key of auctioneer that signs permissions and confirmations */
@@ -64,6 +66,8 @@ export type GuardArgs = {
   collateralToken: Address;
   /** Token that is used as token OUT when swapping Token IN during order execution start */
   stablecoinToken: Address;
+  /** Version that allows having multiple Guards with same `collateral_token` + `stablecoin_token` */
+  version: number;
   /** PDA bump */
   bump: number;
   /** Public key of auctioneer that signs permissions and confirmations */
@@ -72,43 +76,45 @@ export type GuardArgs = {
   collectedFees: number | bigint;
 };
 
-export function getGuardEncoder(): Encoder<GuardArgs> {
+export function getGuardEncoder(): FixedSizeEncoder<GuardArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
       ['collateralToken', getAddressEncoder()],
       ['stablecoinToken', getAddressEncoder()],
+      ['version', getU8Encoder()],
       ['bump', getU8Encoder()],
       ['auctioneerPubKey', getAddressEncoder()],
       ['collectedFees', getU64Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR }),
+    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR })
   );
 }
 
-export function getGuardDecoder(): Decoder<Guard> {
+export function getGuardDecoder(): FixedSizeDecoder<Guard> {
   return getStructDecoder([
     ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
     ['collateralToken', getAddressDecoder()],
     ['stablecoinToken', getAddressDecoder()],
+    ['version', getU8Decoder()],
     ['bump', getU8Decoder()],
     ['auctioneerPubKey', getAddressDecoder()],
     ['collectedFees', getU64Decoder()],
   ]);
 }
 
-export function getGuardCodec(): Codec<GuardArgs, Guard> {
+export function getGuardCodec(): FixedSizeCodec<GuardArgs, Guard> {
   return combineCodec(getGuardEncoder(), getGuardDecoder());
 }
 
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress>
 ): Account<Guard, TAddress>;
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>,
+  encodedAccount: MaybeEncodedAccount<TAddress>
 ): MaybeAccount<Guard, TAddress>;
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
 ): Account<Guard, TAddress> | MaybeAccount<Guard, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getGuardDecoder());
 }
@@ -116,7 +122,7 @@ export function decodeGuard<TAddress extends string = string>(
 export async function fetchGuard<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<Account<Guard, TAddress>> {
   const maybeAccount = await fetchMaybeGuard(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -126,7 +132,7 @@ export async function fetchGuard<TAddress extends string = string>(
 export async function fetchMaybeGuard<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<MaybeAccount<Guard, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeGuard(maybeAccount);
@@ -135,7 +141,7 @@ export async function fetchMaybeGuard<TAddress extends string = string>(
 export async function fetchAllGuard(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<Account<Guard>[]> {
   const maybeAccounts = await fetchAllMaybeGuard(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -145,12 +151,12 @@ export async function fetchAllGuard(
 export async function fetchAllMaybeGuard(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<MaybeAccount<Guard>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));
 }
 
 export function getGuardSize(): number {
-  return 113;
+  return 114;
 }

package/src/core/solana/generated/cross-chain/accounts/index.ts

@@ -7,5 +7,6 @@
  */
 
 export * from './adminSingleton.js';
+export * from './dcaOrder.js';
 export * from './guard.js';
 export * from './order.js';

package/src/core/solana/generated/cross-chain/accounts/order.ts

@@ -18,8 +18,8 @@ import {
   type FetchAccountsConfig,
   type MaybeAccount,
   type MaybeEncodedAccount,
-} from '@solana/kit';
-import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+} from '@solana/accounts';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/addresses';
 import {
   combineCodec,
   fixDecoderSize,
@@ -35,11 +35,11 @@ import {
   getU64Decoder,
   getU64Encoder,
   transformEncoder,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
   type ReadonlyUint8Array,
-} from '@solana/kit';
+} from '@solana/codecs';
 
 export const ORDER_DISCRIMINATOR = new Uint8Array([134, 173, 223, 185, 77, 86, 28, 51]);
 
@@ -118,7 +118,7 @@ export type OrderArgs = {
   executionDeadline: number;
 };
 
-export function getOrderEncoder(): Encoder<OrderArgs> {
+export function getOrderEncoder(): FixedSizeEncoder<OrderArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
@@ -136,11 +136,11 @@ export function getOrderEncoder(): Encoder<OrderArgs> {
       ['activeSolver', getAddressEncoder()],
       ['executionDeadline', getU32Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: ORDER_DISCRIMINATOR }),
+    (value) => ({ ...value, discriminator: ORDER_DISCRIMINATOR })
   );
 }
 
-export function getOrderDecoder(): Decoder<Order> {
+export function getOrderDecoder(): FixedSizeDecoder<Order> {
   return getStructDecoder([
     ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
     ['user', getAddressDecoder()],
@@ -159,18 +159,18 @@ export function getOrderDecoder(): Decoder<Order> {
   ]);
 }
 
-export function getOrderCodec(): Codec<OrderArgs, Order> {
+export function getOrderCodec(): FixedSizeCodec<OrderArgs, Order> {
   return combineCodec(getOrderEncoder(), getOrderDecoder());
 }
 
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress>
 ): Account<Order, TAddress>;
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>,
+  encodedAccount: MaybeEncodedAccount<TAddress>
 ): MaybeAccount<Order, TAddress>;
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
 ): Account<Order, TAddress> | MaybeAccount<Order, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getOrderDecoder());
 }
@@ -178,7 +178,7 @@ export function decodeOrder<TAddress extends string = string>(
 export async function fetchOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<Account<Order, TAddress>> {
   const maybeAccount = await fetchMaybeOrder(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -188,7 +188,7 @@ export async function fetchOrder<TAddress extends string = string>(
 export async function fetchMaybeOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig,
+  config?: FetchAccountConfig
 ): Promise<MaybeAccount<Order, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeOrder(maybeAccount);
@@ -197,7 +197,7 @@ export async function fetchMaybeOrder<TAddress extends string = string>(
 export async function fetchAllOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<Account<Order>[]> {
   const maybeAccounts = await fetchAllMaybeOrder(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -207,7 +207,7 @@ export async function fetchAllOrder(
 export async function fetchAllMaybeOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig,
+  config?: FetchAccountsConfig
 ): Promise<MaybeAccount<Order>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeOrder(maybeAccount));