@shogun-sdk/intents-sdk 1.2.1 → 1.2.3

package/src/core/solana/generated/cross-chain/errors/sourceChainGuard.ts

@@ -6,29 +6,169 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { type Address } from '@solana/kit';
-import { type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, type SolanaError } from '@solana/kit';
-import { isProgramError } from '@solana/kit';
+import { type Address } from '@solana/addresses';
+import { type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, type SolanaError } from '@solana/errors';
+import { isProgramError } from '@solana/programs';
 import { SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS } from '../programs/index.js';
 
+/** NotUpgradeAuthority: Account is not upgrade authority */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY = 0x1770; // 6000
+/** NotAdmin: Account is not Admin */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_ADMIN = 0x1771; // 6001
+/** NotPendingAdmin: Account is not Pending Admin */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN = 0x1772; // 6002
+/** NotASolver: Account is not a Solver */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_A_SOLVER = 0x1773; // 6003
+/** NotAUser: Account is not a User */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_A_USER = 0x1774; // 6004
+/** ZeroAmount: Amount must not be zero */
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT = 0x1775; // 6005
+/** ZeroAmountIn: Amount IN must not be zero */
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN = 0x1776; // 6006
+/** ZeroMinStablecoins: Min stablecoins amount must not be zero */
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_MIN_STABLECOINS = 0x1777; // 6007
+/** WrongOrder: Wrong order */
+export const SOURCE_CHAIN_GUARD_ERROR__WRONG_ORDER = 0x1778; // 6008
+/** InvalidGuard: Invalid Guard */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_GUARD = 0x1779; // 6009
+/** ExpiredDeadline: Expired deadline */
+export const SOURCE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE = 0x177a; // 6010
+/** InvalidStartPermission: Invalid permission */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION = 0x177b; // 6011
+/** InvalidSuccessConfirmation: Invalid success confirmation */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SUCCESS_CONFIRMATION = 0x177c; // 6012
+/** OrderIsBeingExecuted: Order is being executed */
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_BEING_EXECUTED = 0x177d; // 6013
+/** InvalidRecoverToken: Invalid recover token */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_RECOVER_TOKEN = 0x177e; // 6014
+/** AccountNotProvided: Account not provided */
+export const SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED = 0x177f; // 6015
+/** CpiCallNotAllowed: CPI call is not allowed */
+export const SOURCE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED = 0x1780; // 6016
+/** FeeTransferNotAllowed: Fee transfer not allowed */
+export const SOURCE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED = 0x1781; // 6017
+/** InvalidIntervalDuration: Invalid interval duration */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION = 0x1782; // 6018
+/** SwapNotAllowed: Swap is not allowed */
+export const SOURCE_CHAIN_GUARD_ERROR__SWAP_NOT_ALLOWED = 0x1783; // 6019
+/** NoAfterSwapInstructionFound: No _after_swap instruction found */
+export const SOURCE_CHAIN_GUARD_ERROR__NO_AFTER_SWAP_INSTRUCTION_FOUND = 0x1784; // 6020
+/** InvalidAfterSwapInstruction: Invalid _after_swap instruction */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_AFTER_SWAP_INSTRUCTION = 0x1785; // 6021
+/** AlreadySwapped: Tokens IN were already swapped */
+export const SOURCE_CHAIN_GUARD_ERROR__ALREADY_SWAPPED = 0x1786; // 6022
+/** SwapWasNotInitiated: Swap wasn't initiated */
+export const SOURCE_CHAIN_GUARD_ERROR__SWAP_WAS_NOT_INITIATED = 0x1787; // 6023
+/** BelowMinStablecoinsAmount: Below minimum stablecoins amount */
+export const SOURCE_CHAIN_GUARD_ERROR__BELOW_MIN_STABLECOINS_AMOUNT = 0x1788; // 6024
+/** CollateralTokenAccountsNotProvided: Collateral token accounts not provided */
+export const SOURCE_CHAIN_GUARD_ERROR__COLLATERAL_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x1789; // 6025
+/** StablecoinAccountsNotProvided: Stablecoin accounts not provided */
+export const SOURCE_CHAIN_GUARD_ERROR__STABLECOIN_ACCOUNTS_NOT_PROVIDED = 0x178a; // 6026
+/** RecoverTokenAccountsNotProvided: Recover token accounts not provided */
+export const SOURCE_CHAIN_GUARD_ERROR__RECOVER_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x178b; // 6027
+/** InvalidDestTokenAccount: Invalid dest token account */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DEST_TOKEN_ACCOUNT = 0x178c; // 6028
+/** OrderIsCancelled: Order is cancelled */
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_CANCELLED = 0x178d; // 6029
+/** OrderIsFulfilled: Order is fulfilled */
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_FULFILLED = 0x178e; // 6030
+/** InvalidDcaOrder: Invalid DCA order */
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER = 0x178f; // 6031
+/** IntervalWasAlreadyClaimed: Interval was already claimed */
+export const SOURCE_CHAIN_GUARD_ERROR__INTERVAL_WAS_ALREADY_CLAIMED = 0x1790; // 6032
+/** CantStartOrderExecutionDuringThisInterval: Cant start order execution during this interval */
+export const SOURCE_CHAIN_GUARD_ERROR__CANT_START_ORDER_EXECUTION_DURING_THIS_INTERVAL = 0x1791; // 6033
+/** PreviousIntervalCollateralTokenAccountNotProvided: Previous interval collateral token account not provided */
+export const SOURCE_CHAIN_GUARD_ERROR__PREVIOUS_INTERVAL_COLLATERAL_TOKEN_ACCOUNT_NOT_PROVIDED = 0x1792; // 6034
 /** InstructionNotFound: Ed25519Program instruction */
-export const SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND = 0x1770; // 6000
+export const SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND = 0x1793; // 6035
 /** SigVerificationFailed: Signature verification failed */
-export const SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED = 0x1771; // 6001
+export const SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED = 0x1794; // 6036
 /** InvalidSigner: Invalid signer */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER = 0x1772; // 6002
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER = 0x1795; // 6037
 
 export type SourceChainGuardError =
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ALREADY_SWAPPED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__BELOW_MIN_STABLECOINS_AMOUNT
+  | typeof SOURCE_CHAIN_GUARD_ERROR__CANT_START_ORDER_EXECUTION_DURING_THIS_INTERVAL
+  | typeof SOURCE_CHAIN_GUARD_ERROR__COLLATERAL_TOKEN_ACCOUNTS_NOT_PROVIDED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE
+  | typeof SOURCE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED
   | typeof SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INTERVAL_WAS_ALREADY_CLAIMED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_AFTER_SWAP_INSTRUCTION
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_DEST_TOKEN_ACCOUNT
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_GUARD
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_RECOVER_TOKEN
   | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER
-  | typeof SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED;
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION
+  | typeof SOURCE_CHAIN_GUARD_ERROR__INVALID_SUCCESS_CONFIRMATION
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NO_AFTER_SWAP_INSTRUCTION_FOUND
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NOT_ADMIN
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NOT_A_SOLVER
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NOT_A_USER
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN
+  | typeof SOURCE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_BEING_EXECUTED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_CANCELLED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_FULFILLED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__PREVIOUS_INTERVAL_COLLATERAL_TOKEN_ACCOUNT_NOT_PROVIDED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__RECOVER_TOKEN_ACCOUNTS_NOT_PROVIDED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__STABLECOIN_ACCOUNTS_NOT_PROVIDED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__SWAP_NOT_ALLOWED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__SWAP_WAS_NOT_INITIATED
+  | typeof SOURCE_CHAIN_GUARD_ERROR__WRONG_ORDER
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN
+  | typeof SOURCE_CHAIN_GUARD_ERROR__ZERO_MIN_STABLECOINS;
 
 let sourceChainGuardErrorMessages: Record<SourceChainGuardError, string> | undefined;
 if (process.env.NODE_ENV !== 'production') {
   sourceChainGuardErrorMessages = {
+    [SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED]: `Account not provided`,
+    [SOURCE_CHAIN_GUARD_ERROR__ALREADY_SWAPPED]: `Tokens IN were already swapped`,
+    [SOURCE_CHAIN_GUARD_ERROR__BELOW_MIN_STABLECOINS_AMOUNT]: `Below minimum stablecoins amount`,
+    [SOURCE_CHAIN_GUARD_ERROR__CANT_START_ORDER_EXECUTION_DURING_THIS_INTERVAL]: `Cant start order execution during this interval`,
+    [SOURCE_CHAIN_GUARD_ERROR__COLLATERAL_TOKEN_ACCOUNTS_NOT_PROVIDED]: `Collateral token accounts not provided`,
+    [SOURCE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED]: `CPI call is not allowed`,
+    [SOURCE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE]: `Expired deadline`,
+    [SOURCE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED]: `Fee transfer not allowed`,
     [SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND]: `Ed25519Program instruction`,
+    [SOURCE_CHAIN_GUARD_ERROR__INTERVAL_WAS_ALREADY_CLAIMED]: `Interval was already claimed`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_AFTER_SWAP_INSTRUCTION]: `Invalid _after_swap instruction`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER]: `Invalid DCA order`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_DEST_TOKEN_ACCOUNT]: `Invalid dest token account`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_GUARD]: `Invalid Guard`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION]: `Invalid interval duration`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_RECOVER_TOKEN]: `Invalid recover token`,
     [SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER]: `Invalid signer`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION]: `Invalid permission`,
+    [SOURCE_CHAIN_GUARD_ERROR__INVALID_SUCCESS_CONFIRMATION]: `Invalid success confirmation`,
+    [SOURCE_CHAIN_GUARD_ERROR__NO_AFTER_SWAP_INSTRUCTION_FOUND]: `No _after_swap instruction found`,
+    [SOURCE_CHAIN_GUARD_ERROR__NOT_ADMIN]: `Account is not Admin`,
+    [SOURCE_CHAIN_GUARD_ERROR__NOT_A_SOLVER]: `Account is not a Solver`,
+    [SOURCE_CHAIN_GUARD_ERROR__NOT_A_USER]: `Account is not a User`,
+    [SOURCE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN]: `Account is not Pending Admin`,
+    [SOURCE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY]: `Account is not upgrade authority`,
+    [SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_BEING_EXECUTED]: `Order is being executed`,
+    [SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_CANCELLED]: `Order is cancelled`,
+    [SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_FULFILLED]: `Order is fulfilled`,
+    [SOURCE_CHAIN_GUARD_ERROR__PREVIOUS_INTERVAL_COLLATERAL_TOKEN_ACCOUNT_NOT_PROVIDED]: `Previous interval collateral token account not provided`,
+    [SOURCE_CHAIN_GUARD_ERROR__RECOVER_TOKEN_ACCOUNTS_NOT_PROVIDED]: `Recover token accounts not provided`,
     [SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED]: `Signature verification failed`,
+    [SOURCE_CHAIN_GUARD_ERROR__STABLECOIN_ACCOUNTS_NOT_PROVIDED]: `Stablecoin accounts not provided`,
+    [SOURCE_CHAIN_GUARD_ERROR__SWAP_NOT_ALLOWED]: `Swap is not allowed`,
+    [SOURCE_CHAIN_GUARD_ERROR__SWAP_WAS_NOT_INITIATED]: `Swap wasn't initiated`,
+    [SOURCE_CHAIN_GUARD_ERROR__WRONG_ORDER]: `Wrong order`,
+    [SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT]: `Amount must not be zero`,
+    [SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN]: `Amount IN must not be zero`,
+    [SOURCE_CHAIN_GUARD_ERROR__ZERO_MIN_STABLECOINS]: `Min stablecoins amount must not be zero`,
   };
 }
 
@@ -43,8 +183,13 @@ export function getSourceChainGuardErrorMessage(code: SourceChainGuardError): st
 export function isSourceChainGuardError<TProgramErrorCode extends SourceChainGuardError>(
   error: unknown,
   transactionMessage: { instructions: Record<number, { programAddress: Address }> },
-  code?: TProgramErrorCode,
+  code?: TProgramErrorCode
 ): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
   Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
-  return isProgramError<TProgramErrorCode>(error, transactionMessage, SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS, code);
+  return isProgramError<TProgramErrorCode>(
+    error,
+    transactionMessage,
+    SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
+    code
+  );
 }

package/src/core/solana/generated/cross-chain/instructions/acceptAdmin.ts

@@ -6,7 +6,7 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { getProgramDerivedAddress, type Address } from '@solana/kit';
+import { getProgramDerivedAddress, type Address } from '@solana/addresses';
 import {
   combineCodec,
   fixDecoderSize,
@@ -16,20 +16,20 @@ import {
   getStructDecoder,
   getStructEncoder,
   transformEncoder,
-  type Codec,
-  type Decoder,
-  type Encoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
   type ReadonlyUint8Array,
-} from '@solana/kit';
+} from '@solana/codecs';
 import {
-  type IAccountMeta,
-  type IInstruction,
-  type IInstructionWithAccounts,
-  type IInstructionWithData,
+  type AccountMeta,
+  type Instruction,
+  type InstructionWithAccounts,
+  type InstructionWithData,
   type WritableAccount,
   type WritableSignerAccount,
-} from '@solana/kit';
-import { type IAccountSignerMeta, type TransactionSigner } from '@solana/kit';
+} from '@solana/instructions';
+import { type AccountSignerMeta, type TransactionSigner } from '@solana/signers';
 import { SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS } from '../programs/index.js';
 import { getAccountMetaFactory, type ResolvedAccount } from '../shared/index.js';
 
@@ -41,41 +41,46 @@ export function getAcceptAdminDiscriminatorBytes() {
 
 export type AcceptAdminInstruction<
   TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
-  TAccountPendingAdmin extends string | IAccountMeta<string> = string,
-  TAccountAdminSingleton extends string | IAccountMeta<string> = string,
-  TRemainingAccounts extends readonly IAccountMeta<string>[] = [],
-> = IInstruction<TProgram> &
-  IInstructionWithData<Uint8Array> &
-  IInstructionWithAccounts<
+  TAccountPendingAdmin extends string | AccountMeta<string> = string,
+  TAccountAdminSingleton extends string | AccountMeta<string> = string,
+  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+  InstructionWithData<ReadonlyUint8Array> &
+  InstructionWithAccounts<
     [
       TAccountPendingAdmin extends string
-        ? WritableSignerAccount<TAccountPendingAdmin> & IAccountSignerMeta<TAccountPendingAdmin>
+        ? WritableSignerAccount<TAccountPendingAdmin> & AccountSignerMeta<TAccountPendingAdmin>
         : TAccountPendingAdmin,
-      TAccountAdminSingleton extends string ? WritableAccount<TAccountAdminSingleton> : TAccountAdminSingleton,
+      TAccountAdminSingleton extends string
+        ? WritableAccount<TAccountAdminSingleton>
+        : TAccountAdminSingleton,
       ...TRemainingAccounts,
     ]
   >;
 
 export type AcceptAdminInstructionData = { discriminator: ReadonlyUint8Array };
 
-export type AcceptAdminInstructionDataArgs = object;
+export type AcceptAdminInstructionDataArgs = Object;
 
-export function getAcceptAdminInstructionDataEncoder(): Encoder<AcceptAdminInstructionDataArgs> {
-  return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({
-    ...value,
-    discriminator: ACCEPT_ADMIN_DISCRIMINATOR,
-  }));
+export function getAcceptAdminInstructionDataEncoder(): FixedSizeEncoder<AcceptAdminInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: ACCEPT_ADMIN_DISCRIMINATOR })
+  );
 }
 
-export function getAcceptAdminInstructionDataDecoder(): Decoder<AcceptAdminInstructionData> {
+export function getAcceptAdminInstructionDataDecoder(): FixedSizeDecoder<AcceptAdminInstructionData> {
   return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
 }
 
-export function getAcceptAdminInstructionDataCodec(): Codec<
+export function getAcceptAdminInstructionDataCodec(): FixedSizeCodec<
   AcceptAdminInstructionDataArgs,
   AcceptAdminInstructionData
 > {
-  return combineCodec(getAcceptAdminInstructionDataEncoder(), getAcceptAdminInstructionDataDecoder());
+  return combineCodec(
+    getAcceptAdminInstructionDataEncoder(),
+    getAcceptAdminInstructionDataDecoder()
+  );
 }
 
 export type AcceptAdminAsyncInput<
@@ -94,7 +99,7 @@ export async function getAcceptAdminInstructionAsync<
   TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
 >(
   input: AcceptAdminAsyncInput<TAccountPendingAdmin, TAccountAdminSingleton>,
-  config?: { programAddress?: TProgramAddress },
+  config?: { programAddress?: TProgramAddress }
 ): Promise<AcceptAdminInstruction<TProgramAddress, TAccountPendingAdmin, TAccountAdminSingleton>> {
   // Program address.
   const programAddress = config?.programAddress ?? SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS;
@@ -140,7 +145,7 @@ export function getAcceptAdminInstruction<
   TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
 >(
   input: AcceptAdminInput<TAccountPendingAdmin, TAccountAdminSingleton>,
-  config?: { programAddress?: TProgramAddress },
+  config?: { programAddress?: TProgramAddress }
 ): AcceptAdminInstruction<TProgramAddress, TAccountPendingAdmin, TAccountAdminSingleton> {
   // Program address.
   const programAddress = config?.programAddress ?? SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS;
@@ -164,7 +169,7 @@ export function getAcceptAdminInstruction<
 
 export type ParsedAcceptAdminInstruction<
   TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
-  TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
+  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
 > = {
   programAddress: Address<TProgram>;
   accounts: {
@@ -176,8 +181,13 @@ export type ParsedAcceptAdminInstruction<
   data: AcceptAdminInstructionData;
 };
 
-export function parseAcceptAdminInstruction<TProgram extends string, TAccountMetas extends readonly IAccountMeta[]>(
-  instruction: IInstruction<TProgram> & IInstructionWithAccounts<TAccountMetas> & IInstructionWithData<Uint8Array>,
+export function parseAcceptAdminInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly AccountMeta[],
+>(
+  instruction: Instruction<TProgram> &
+    InstructionWithAccounts<TAccountMetas> &
+    InstructionWithData<ReadonlyUint8Array>
 ): ParsedAcceptAdminInstruction<TProgram, TAccountMetas> {
   if (instruction.accounts.length < 2) {
     // TODO: Coded error.
@@ -185,7 +195,7 @@ export function parseAcceptAdminInstruction<TProgram extends string, TAccountMet
   }
   let accountIndex = 0;
   const getNextAccount = () => {
-    const accountMeta = instruction.accounts![accountIndex]!;
+    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
     accountIndex += 1;
     return accountMeta;
   };