@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

package/src/core/sdk.ts

@@ -1,11 +1,15 @@
-import { chainIdToChainTypeMap } from '../chains.js';
 import { AUCTIONEER_URL } from '../constants.js';
 import { NetworkError } from '../errors/index.js';
 import type { ApiResponse } from '../types/api.js';
-import type { CreateOrderParams, PreparedOrder, UserIntentRequest } from '../types/intent.js';
-import { calculateAmounts } from '../utils/defillama.js';
+import type {
+  CrossChainOrderPrepared,
+  CrossChainUserIntentRequest,
+  SingleChainOrderPrepared,
+  SingleChainUserIntentRequest,
+} from '../types/intent.js';
 import { Parsers } from '../utils/parsers.js';
-import { Order } from './order.js';
+import { CrossChainOrder, type CreateCrossChainOrderParams } from './orders/cross-chain.js';
+import { SingleChainOrder, type CreateSingleChainOrderParams } from './orders/single-chain.js';
 
 /**
  * Base SDK providing common functionality for all blockchain implementations
@@ -15,153 +19,116 @@ import { Order } from './order.js';
  * across different blockchains.
  */
 export abstract class BaseSDK {
-  /**
-   * Gets the user's wallet address derived from their private key
-   *
-   * @returns Promise resolving to the user's address as a string
-   * @abstract Must be implemented by each chain-specific SDK
-   */
   public abstract getUserAddress(): Promise<string>;
+  protected abstract prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+  protected abstract prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
 
-  protected abstract cancelOrderInternal(orderId: string): Promise<string>;
-
-  /**
-   * Prepares an order for submission with chain-specific logic
-   *
-   * This method handles the chain-specific aspects of order creation, such as:
-   * - Creating and signing transactions
-   * - Interacting with blockchain-specific smart contracts
-   * - Generating proof of intent
-   *
-   * @param order The validated order to prepare
-   * @returns Promise resolving to a prepared order with chain-specific data
-   * @abstract Must be implemented by each chain-specific SDK
-   * @protected
-   */
-  protected abstract prepareOrder(order: Order): Promise<PreparedOrder>;
-
-  /**
-   * Creates a cross-chain swap order
-   *
-   * This method:
-   * 1. Gets the user's address from their private key
-   * 2. Creates and validates an Order instance
-   * 3. Delegates to chain-specific preparation logic
-   *
-   * @param params Parameters for order creation including source/destination chain details
-   * @returns Promise resolving to a prepared order ready for submission
-   * @throws {ValidationError} If order parameters are invalid
-   * @throws {OrderCreationError} If order creation fails
-   */
-  public async createOrder(params: CreateOrderParams): Promise<PreparedOrder> {
+  public async createSingleChainOrder(params: CreateSingleChainOrderParams): Promise<SingleChainOrderPrepared> {
     const userAddress = await this.getUserAddress();
 
-    let minStablecoinAmount: bigint;
-    let destinationTokenMinAmount: bigint;
-
-    if (!params.minStablecoinAmount || !params.destinationTokenMinAmount) {
-      // Calculate missing values using DefiLlama
-      const { amountOut: calculatedAmountOut, minStablecoinsAmount: calculatedMinStablecoins } = await calculateAmounts(
-        {
-          srcChainId: params.sourceChainId,
-          tokenIn: params.sourceTokenAddress,
-          amountIn: params.sourceTokenAmount,
-          destChainId: params.destinationChainId,
-          tokenOut: params.destinationTokenAddress,
-        },
-      );
+    const order = await SingleChainOrder.create({
+      ...params,
+      user: userAddress,
+    });
 
-      // Use provided values if available, otherwise use calculated ones
-      minStablecoinAmount = params.minStablecoinAmount ?? calculatedMinStablecoins;
-      destinationTokenMinAmount = params.destinationTokenMinAmount ?? calculatedAmountOut;
-    } else {
-      // Both values provided, use them directly
-      minStablecoinAmount = params.minStablecoinAmount;
-      destinationTokenMinAmount = params.destinationTokenMinAmount;
-    }
+    return this.prepareSingleChainOrder(order);
+  }
+
+  public async createCrossChainOrder(params: CreateCrossChainOrderParams): Promise<CrossChainOrderPrepared> {
+    const userAddress = await this.getUserAddress();
 
-    // Order is validated upon creation
-    const order = await Order.create({
+    const order = await CrossChainOrder.create({
+      ...params,
       user: userAddress,
-      sourceChainId: params.sourceChainId,
-      sourceTokenAddress: params.sourceTokenAddress,
-      sourceTokenAmount: params.sourceTokenAmount,
-      minStablecoinAmount: minStablecoinAmount,
-      deadline: params.deadline,
-      destinationAddress: params.destinationAddress,
-      destinationChainId: params.destinationChainId,
-      destinationTokenAddress: params.destinationTokenAddress,
-      destinationTokenMinAmount: destinationTokenMinAmount,
-      extraTransfers: params.extraTransfers,
     });
 
-    return this.prepareOrder(order);
+    return this.prepareCrossChainOrder(order);
   }
 
-  public async cancelOrder(orderId: string): Promise<string> {
-    return this.cancelOrderInternal(orderId);
+  public async createAndSendSingleChainOrder(params: CreateSingleChainOrderParams): Promise<ApiResponse> {
+    const preparedOrder = await this.createSingleChainOrder(params);
+    return BaseSDK.sendSingleChainOrder(preparedOrder);
+  }
+
+  public static async sendSingleChainOrder(preparedOrder: SingleChainOrderPrepared): Promise<ApiResponse> {
+    const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+
+    const url = `${AUCTIONEER_URL}/user_intent/single_chain/limit_order`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const errorJson: ApiResponse = await response.json();
+
+      const extraErrorData = errorJson.extra_error_data;
+      throw new NetworkError(`Server error ${extraErrorData}`);
+    }
+
+    return response.json();
   }
 
-  /**
-   * Creates an order and sends it to the auctioneer in a single call
-   *
-   * Convenience method that combines order creation and submission
-   *
-   * @param params Parameters for order creation including source/destination chain details
-   * @returns Promise resolving to the auctioneer's HTTP response
-   * @throws {ValidationError} If order parameters are invalid
-   * @throws {OrderCreationError} If order creation fails
-   * @throws {NetworkError} If order submission fails
-   */
-  public async createAndSendOrder(params: CreateOrderParams): Promise<ApiResponse> {
-    const preparedOrder = await this.createOrder(params);
-    return BaseSDK.sendOrder(preparedOrder);
+  public static async validateCrossChainOrder(intentRequest: CrossChainUserIntentRequest): Promise<void> {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+
+    const url = `${AUCTIONEER_URL}/validate_intent/cross_chain/limit_order`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const errorJson: ApiResponse = await response.json();
+
+      const mainError = errorJson.error;
+      const extraErrorData = errorJson.extra_error_data;
+      throw new NetworkError(`Validation error: ${mainError}. Extra error data: ${extraErrorData}`);
+    }
+
+    return;
   }
 
-  /**
-   * Converts a prepared order into a user intent request format for the auctioneer
-   *
-   * The UserIntentRequest format includes:
-   * - Generic data common to all chains
-   * - Chain-specific data (signatures, nonces, etc.)
-   * - Execution details for the destination chain
-   *
-   * @param preparedOrder The prepared order with chain-specific data
-   * @returns User intent request object ready for submission to the auctioneer
-   * @throws {BaseError} If conversion fails
-   */
-  public static getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
-    const sourceChain = preparedOrder.order.sourceChainId;
-    const sourceChainType = chainIdToChainTypeMap[sourceChain];
-    const executionDetails = preparedOrder.order.getExecutionDetails();
-
-    return {
-      genericData: preparedOrder.order.toSourceChainData(),
-      executionDetails: JSON.stringify(executionDetails, Parsers.bigIntReplacer),
-      chainSpecificData: {
-        [sourceChainType]: preparedOrder.preparedData,
+  public static async validateSingleChainOrder(intentRequest: SingleChainUserIntentRequest): Promise<void> {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+
+    const url = `${AUCTIONEER_URL}/validate_intent/single_chain/limit_order`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
       },
-    };
+      body,
+    });
+
+    if (!response.ok) {
+      const errorJson: ApiResponse = await response.json();
+
+      const mainError = errorJson.error;
+      const extraErrorData = errorJson.extra_error_data;
+      throw new NetworkError(`Validation error: ${mainError}. Extra error data: ${extraErrorData}`);
+    }
+
+    return;
   }
 
-  /**
-   * Sends a prepared order to the auctioneer service
-   *
-   * This method:
-   * 1. Converts the prepared order to the auctioneer's expected format
-   * 2. Serializes the request with proper handling of bigint values
-   * 3. Submits the order to the auctioneer endpoint
-   * 4. Validates the response
-   *
-   * @param preparedOrder The prepared order with chain-specific data
-   * @returns Promise resolving to the specific-chain tx hash
-   * @throws {NetworkError} If the network request fails or returns an error
-   */
-  public static async sendOrder(preparedOrder: PreparedOrder): Promise<ApiResponse> {
-    const intentRequest = BaseSDK.getUserIntentRequest(preparedOrder);
+  public async createAndSendCrossChainOrder(params: CreateCrossChainOrderParams): Promise<ApiResponse> {
+    const preparedOrder = await this.createCrossChainOrder(params);
+    return BaseSDK.sendCrossChainOrder(preparedOrder);
+  }
+
+  public static async sendCrossChainOrder(preparedOrder: CrossChainOrderPrepared): Promise<ApiResponse> {
+    const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
     const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
 
-    const url = `${AUCTIONEER_URL}/user_intent`;
+    const url = `${AUCTIONEER_URL}/user_intent/cross_chain/limit_order`;
     const response = await fetch(url, {
       method: 'POST',
       headers: {
@@ -173,12 +140,11 @@ export abstract class BaseSDK {
     if (!response.ok) {
       const errorJson: ApiResponse = await response.json();
 
+      const mainError = errorJson.error;
       const extraErrorData = errorJson.extra_error_data;
-      throw new NetworkError(`Server error`, {
-        status: response.status,
-        statusText: response.statusText,
-        body: extraErrorData,
-      });
+      throw new NetworkError(
+        `Failed to send cross-chain order. Main error: ${mainError}. Extra error data: ${extraErrorData}`,
+      );
     }
 
     return response.json();

package/src/core/solana/cancel-order.ts

@@ -0,0 +1,264 @@
+import {
+  address,
+  appendTransactionMessageInstructions,
+  compileTransactionMessage,
+  createNoopSigner,
+  createSolanaRpc,
+  createTransactionMessage,
+  fetchEncodedAccount,
+  getAddressEncoder,
+  getCompiledTransactionMessageEncoder,
+  getProgramDerivedAddress,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Address,
+  type IInstruction,
+  type ReadonlyUint8Array,
+  type TransactionMessageBytes,
+} from '@solana/kit';
+import { getDefaultSolanaRPC } from './client.js';
+import { fetchMaybeLimitOrder, getCancelLimitOrderInstruction } from './generated/single-chain/index.js';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMint,
+  getCreateAssociatedTokenInstructionAsync,
+} from '@solana-program/token';
+import { CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, SOLANA_MINT_TOKEN } from '../../constants.js';
+import { ChainID } from '../../chains.js';
+import { fetchMaybeOrder, getCancelOrderInstruction } from './generated/cross-chain/index.js';
+
+export async function cancelSingleChainOrderInstructions(
+  orderAddress: string,
+  options?: { rpcUrl?: string },
+): Promise<IInstruction[]> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+
+  const orderId = address(orderAddress);
+  const chainOrder = await fetchMaybeLimitOrder(rpc, orderId);
+
+  if (!chainOrder.exists) {
+    throw new Error(`Order with address ${orderAddress} not found`);
+  }
+
+  const instructions: IInstruction[] = [];
+  const orderUserAddress = chainOrder.data.user;
+
+  const tokenInMint = chainOrder.data.tokenInMint;
+
+  const tokenMintProgram = await fetchMint(rpc, tokenInMint);
+
+  const addressEncoder = getAddressEncoder();
+
+  const [tokenInProgramAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(orderUserAddress),
+      addressEncoder.encode(tokenMintProgram.programAddress),
+      addressEncoder.encode(tokenInMint),
+    ],
+  });
+
+  const guardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana] as Address;
+  const [guardProgramAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      // Owner
+      addressEncoder.encode(guardAddress),
+      // Token program
+      addressEncoder.encode(tokenMintProgram.programAddress),
+      // mint address
+      addressEncoder.encode(tokenInMint),
+    ],
+  });
+
+  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
+
+  if (!userTokenInAccount.exists) {
+    const createTokenIx = await getCreateAssociatedTokenInstructionAsync({
+      mint: tokenInMint,
+      owner: orderUserAddress,
+      payer: createNoopSigner(orderUserAddress),
+      tokenProgram: tokenMintProgram.programAddress,
+    });
+
+    instructions.push(createTokenIx);
+  }
+
+  const cancelLimitOrderIx = getCancelLimitOrderInstruction({
+    user: createNoopSigner(orderUserAddress),
+    order: orderId,
+    guard: guardAddress,
+    tokenInMint: chainOrder.data.tokenInMint,
+    userTokenInAccount: userTokenInAccount.address,
+    guardTokenInAccount: guardProgramAccount,
+    tokenInProgram: tokenMintProgram.programAddress,
+  });
+
+  instructions.push(cancelLimitOrderIx);
+
+  return instructions;
+}
+
+export async function cancelCrossChainOrderInstructionsAsBytes(
+  orderAddress: string,
+  signerAddress: string,
+  options?: { rpcUrl?: string },
+): Promise<{ versionedMessageBytes: ReadonlyUint8Array }> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const instructions = await cancelCrossChainOrderInstructions(orderAddress, options);
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
+
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(createNoopSigner(address(signerAddress)), tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+  );
+
+  const compiledTxMessage = compileTransactionMessage(txMessage);
+
+  const txBytes = getCompiledTransactionMessageEncoder().encode(compiledTxMessage);
+
+  return { versionedMessageBytes: txBytes };
+}
+
+export async function cancelSingleChainOrderInstructionsAsBytes(
+  orderAddress: string,
+  signerAddress: string,
+  options?: { rpcUrl?: string },
+): Promise<{ versionedMessageBytes: ReadonlyUint8Array }> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const instructions = await cancelSingleChainOrderInstructions(orderAddress, options);
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
+
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(createNoopSigner(address(signerAddress)), tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+  );
+
+  const compiledTxMessage = compileTransactionMessage(txMessage);
+
+  const txBytes = getCompiledTransactionMessageEncoder().encode(compiledTxMessage) as TransactionMessageBytes;
+
+  return { versionedMessageBytes: txBytes };
+}
+
+export async function cancelCrossChainOrderInstructions(
+  orderAddress: string,
+  options?: { rpcUrl?: string },
+): Promise<IInstruction[]> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderId = address(orderAddress);
+
+  const chainOrder = await fetchMaybeOrder(rpc, orderId);
+  if (!chainOrder.exists) {
+    throw new Error(`Order with address ${orderAddress} not found`);
+  }
+
+  const instructions: IInstruction[] = [];
+  const orderUserAddress = chainOrder.data.user;
+  const guardAddress = CROSS_CHAIN_GUARD_ADDRESSES[ChainID.Solana] as Address;
+  const addressEncoder = getAddressEncoder();
+
+  const isRecoveringTokenIn = chainOrder.data.lockedStablecoins === 0n;
+  const recoverTokenMint = isRecoveringTokenIn ? chainOrder.data.tokenInMint : address(SOLANA_MINT_TOKEN.mint); 
+
+  const recoverTokenMintProgram = await fetchMint(rpc, recoverTokenMint);
+
+  const [userRecoveredTokenAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(orderUserAddress),
+      addressEncoder.encode(recoverTokenMintProgram.programAddress),
+      addressEncoder.encode(recoverTokenMint),
+    ],
+  });
+
+  const [guardRecoveredTokenAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(guardAddress),
+      addressEncoder.encode(recoverTokenMintProgram.programAddress),
+      addressEncoder.encode(recoverTokenMint),
+    ],
+  });
+
+  // Check if user's recovered token account exists, create if needed
+  const userRecoveredTokenAccountInfo = await fetchEncodedAccount(rpc, userRecoveredTokenAccount);
+  if (!userRecoveredTokenAccountInfo.exists) {
+    const createRecoveredTokenAccountIx = await getCreateAssociatedTokenInstructionAsync({
+      payer: createNoopSigner(orderUserAddress),
+      ata: userRecoveredTokenAccount,
+      owner: orderUserAddress,
+      mint: recoverTokenMint,
+      tokenProgram: recoverTokenMintProgram.programAddress,
+    });
+    instructions.push(createRecoveredTokenAccountIx);
+  }
+
+  let userCollateralTokenAccount: Address | undefined;
+  const willClaimCollateral = chainOrder.data.lockedCollateral > 0n;
+
+  if (willClaimCollateral) {
+    const collateralTokenMint = address(SOLANA_MINT_TOKEN.mint);
+    const collateralTokenMintProgram = await fetchMint(rpc, collateralTokenMint);
+
+    const [userCollateralAccount] = await getProgramDerivedAddress({
+      programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+      seeds: [
+        addressEncoder.encode(orderUserAddress),
+        addressEncoder.encode(collateralTokenMintProgram.programAddress),
+        addressEncoder.encode(collateralTokenMint),
+      ],
+    });
+
+    userCollateralTokenAccount = userCollateralAccount;
+
+    // Check if user's collateral token account exists, create if needed
+    const userCollateralTokenAccountInfo = await fetchEncodedAccount(rpc, userCollateralTokenAccount);
+    if (!userCollateralTokenAccountInfo.exists) {
+      const createCollateralTokenAccountIx = await getCreateAssociatedTokenInstructionAsync({
+        payer: createNoopSigner(orderUserAddress),
+        ata: userCollateralTokenAccount,
+        owner: orderUserAddress,
+        mint: collateralTokenMint,
+        tokenProgram: collateralTokenMintProgram.programAddress,
+      });
+      instructions.push(createCollateralTokenAccountIx);
+    }
+  }
+
+  const collateralTokenMint = address(SOLANA_MINT_TOKEN.mint);
+  const collateralTokenMintProgram = await fetchMint(rpc, collateralTokenMint);
+
+  const [guardCollateralTokenAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(guardAddress),
+      addressEncoder.encode(collateralTokenMintProgram.programAddress),
+      addressEncoder.encode(collateralTokenMint),
+    ],
+  });
+
+  // Create the cancel order instruction
+  const cancelOrderIx = getCancelOrderInstruction({
+    user: createNoopSigner(orderUserAddress),
+    order: orderId,
+    guard: guardAddress,
+    recoveredTokenMint: recoverTokenMint,
+    userRecoveredTokenAccount: userRecoveredTokenAccount,
+    guardRecoveredTokenAccount: guardRecoveredTokenAccount,
+    recoveredTokenProgram: recoverTokenMintProgram.programAddress,
+    collateralTokenMint: collateralTokenMint,
+    userCollateralTokenAccount: userCollateralTokenAccount,
+    guardCollateralTokenAccount: guardCollateralTokenAccount,
+    collateralTokenProgram: collateralTokenMintProgram.programAddress,
+  });
+
+  instructions.push(cancelOrderIx);
+
+  return instructions;
+}

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

@@ -7,24 +7,21 @@
  */
 
 import {
-  type Account,
   assertAccountExists,
   assertAccountsExist,
   decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
   type EncodedAccount,
   type FetchAccountConfig,
   type FetchAccountsConfig,
-  fetchEncodedAccount,
-  fetchEncodedAccounts,
   type MaybeAccount,
   type MaybeEncodedAccount,
 } from '@solana/kit';
-import { type Address, getAddressDecoder, getAddressEncoder } from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
 import {
-  type Codec,
   combineCodec,
-  type Decoder,
-  type Encoder,
   fixDecoderSize,
   fixEncoderSize,
   getBytesDecoder,
@@ -33,8 +30,11 @@ import {
   getStructEncoder,
   getU8Decoder,
   getU8Encoder,
-  type ReadonlyUint8Array,
   transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
 } from '@solana/kit';
 
 export const ADMIN_SINGLETON_DISCRIMINATOR = new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194]);
@@ -47,6 +47,8 @@ export type AdminSingleton = {
   discriminator: ReadonlyUint8Array;
   /** Guard admin */
   admin: Address;
+  /** Pending guard admin */
+  pendingAdmin: Address;
   /** PDA bump */
   bump: number;
 };
@@ -54,6 +56,8 @@ export type AdminSingleton = {
 export type AdminSingletonArgs = {
   /** Guard admin */
   admin: Address;
+  /** Pending guard admin */
+  pendingAdmin: Address;
   /** PDA bump */
   bump: number;
 };
@@ -63,6 +67,7 @@ export function getAdminSingletonEncoder(): Encoder<AdminSingletonArgs> {
     getStructEncoder([
       ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
       ['admin', getAddressEncoder()],
+      ['pendingAdmin', getAddressEncoder()],
       ['bump', getU8Encoder()],
     ]),
     (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR }),
@@ -73,6 +78,7 @@ export function getAdminSingletonDecoder(): Decoder<AdminSingleton> {
   return getStructDecoder([
     ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
     ['admin', getAddressDecoder()],
+    ['pendingAdmin', getAddressDecoder()],
     ['bump', getU8Decoder()],
   ]);
 }
@@ -132,5 +138,5 @@ export async function fetchAllMaybeAdminSingleton(
 }
 
 export function getAdminSingletonSize(): number {
-  return 41;
+  return 73;
 }

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

@@ -7,36 +7,36 @@
  */
 
 import {
-  type Account,
   assertAccountExists,
   assertAccountsExist,
   decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
   type EncodedAccount,
   type FetchAccountConfig,
   type FetchAccountsConfig,
-  fetchEncodedAccount,
-  fetchEncodedAccounts,
   type MaybeAccount,
   type MaybeEncodedAccount,
 } from '@solana/kit';
-import { type Address, getAddressDecoder, getAddressEncoder } from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
 import {
-  type Codec,
   combineCodec,
-  type Decoder,
-  type Encoder,
   fixDecoderSize,
   fixEncoderSize,
   getBytesDecoder,
   getBytesEncoder,
   getStructDecoder,
   getStructEncoder,
-  getU8Decoder,
-  getU8Encoder,
   getU64Decoder,
   getU64Encoder,
-  type ReadonlyUint8Array,
+  getU8Decoder,
+  getU8Encoder,
   transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
 } from '@solana/kit';
 
 export const GUARD_DISCRIMINATOR = new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248]);