@shogun-sdk/intents-sdk 1.3.0 → 1.4.0

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

@@ -0,0 +1,322 @@
+/**
+ * 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 { type Address } from '@solana/addresses';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  transformEncoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type ReadonlyUint8Array,
+} from '@solana/codecs';
+import {
+  type AccountMeta,
+  type Instruction,
+  type InstructionWithAccounts,
+  type InstructionWithData,
+  type ReadonlyAccount,
+  type WritableAccount,
+  type WritableSignerAccount,
+} 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';
+
+export const START_DCA_ORDER_EXECUTION_AFTER_SWAP_DISCRIMINATOR = new Uint8Array([
+  30, 107, 27, 130, 23, 22, 101, 198,
+]);
+
+export function getStartDcaOrderExecutionAfterSwapDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    START_DCA_ORDER_EXECUTION_AFTER_SWAP_DISCRIMINATOR
+  );
+}
+
+export type StartDcaOrderExecutionAfterSwapInstruction<
+  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
+  TAccountSolver extends string | AccountMeta<string> = string,
+  TAccountOrder extends string | AccountMeta<string> = string,
+  TAccountGuard extends string | AccountMeta<string> = string,
+  TAccountIxSysvar extends
+    | string
+    | AccountMeta<string> = 'Sysvar1nstructions1111111111111111111111111',
+  TAccountStablecoinTokenMint extends string | AccountMeta<string> = string,
+  TAccountSolverStablecoinTokenAccount extends string | AccountMeta<string> = string,
+  TAccountGuardStablecoinTokenAccount extends string | AccountMeta<string> = string,
+  TAccountStablecoinTokenProgram extends string | AccountMeta<string> = string,
+  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+  InstructionWithData<ReadonlyUint8Array> &
+  InstructionWithAccounts<
+    [
+      TAccountSolver extends string
+        ? WritableSignerAccount<TAccountSolver> & AccountSignerMeta<TAccountSolver>
+        : TAccountSolver,
+      TAccountOrder extends string ? WritableAccount<TAccountOrder> : TAccountOrder,
+      TAccountGuard extends string ? ReadonlyAccount<TAccountGuard> : TAccountGuard,
+      TAccountIxSysvar extends string ? ReadonlyAccount<TAccountIxSysvar> : TAccountIxSysvar,
+      TAccountStablecoinTokenMint extends string
+        ? ReadonlyAccount<TAccountStablecoinTokenMint>
+        : TAccountStablecoinTokenMint,
+      TAccountSolverStablecoinTokenAccount extends string
+        ? WritableAccount<TAccountSolverStablecoinTokenAccount>
+        : TAccountSolverStablecoinTokenAccount,
+      TAccountGuardStablecoinTokenAccount extends string
+        ? WritableAccount<TAccountGuardStablecoinTokenAccount>
+        : TAccountGuardStablecoinTokenAccount,
+      TAccountStablecoinTokenProgram extends string
+        ? ReadonlyAccount<TAccountStablecoinTokenProgram>
+        : TAccountStablecoinTokenProgram,
+      ...TRemainingAccounts,
+    ]
+  >;
+
+export type StartDcaOrderExecutionAfterSwapInstructionData = {
+  discriminator: ReadonlyUint8Array;
+  stablecoinsAmount: bigint;
+};
+
+export type StartDcaOrderExecutionAfterSwapInstructionDataArgs = {
+  stablecoinsAmount: number | bigint;
+};
+
+export function getStartDcaOrderExecutionAfterSwapInstructionDataEncoder(): FixedSizeEncoder<StartDcaOrderExecutionAfterSwapInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['stablecoinsAmount', getU64Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: START_DCA_ORDER_EXECUTION_AFTER_SWAP_DISCRIMINATOR })
+  );
+}
+
+export function getStartDcaOrderExecutionAfterSwapInstructionDataDecoder(): FixedSizeDecoder<StartDcaOrderExecutionAfterSwapInstructionData> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['stablecoinsAmount', getU64Decoder()],
+  ]);
+}
+
+export function getStartDcaOrderExecutionAfterSwapInstructionDataCodec(): FixedSizeCodec<
+  StartDcaOrderExecutionAfterSwapInstructionDataArgs,
+  StartDcaOrderExecutionAfterSwapInstructionData
+> {
+  return combineCodec(
+    getStartDcaOrderExecutionAfterSwapInstructionDataEncoder(),
+    getStartDcaOrderExecutionAfterSwapInstructionDataDecoder()
+  );
+}
+
+export type StartDcaOrderExecutionAfterSwapInput<
+  TAccountSolver extends string = string,
+  TAccountOrder extends string = string,
+  TAccountGuard extends string = string,
+  TAccountIxSysvar extends string = string,
+  TAccountStablecoinTokenMint extends string = string,
+  TAccountSolverStablecoinTokenAccount extends string = string,
+  TAccountGuardStablecoinTokenAccount extends string = string,
+  TAccountStablecoinTokenProgram extends string = string,
+> = {
+  /** Solver that starts DCA order execution */
+  solver: TransactionSigner<TAccountSolver>;
+  /** DCA order data */
+  order: Address<TAccountOrder>;
+  /** Guard address, that protects this DCA order execution */
+  guard: Address<TAccountGuard>;
+  /**
+   * the supplied Sysvar could be anything else.
+   * The Instruction Sysvar has not been implemented
+   * in the Anchor framework yet, so this is the safe approach.
+   */
+  ixSysvar?: Address<TAccountIxSysvar>;
+  /** Stablecoin token mint */
+  stablecoinTokenMint: Address<TAccountStablecoinTokenMint>;
+  /**
+   * Solver stablecoin account, from which solver is paying stablecoin tokens
+   * after swapping Tokens IN
+   */
+  solverStablecoinTokenAccount: Address<TAccountSolverStablecoinTokenAccount>;
+  /** Guard stablecoin account, where Guard is collecting stablecoins */
+  guardStablecoinTokenAccount: Address<TAccountGuardStablecoinTokenAccount>;
+  /** Solana token program */
+  stablecoinTokenProgram: Address<TAccountStablecoinTokenProgram>;
+  stablecoinsAmount: StartDcaOrderExecutionAfterSwapInstructionDataArgs['stablecoinsAmount'];
+};
+
+export function getStartDcaOrderExecutionAfterSwapInstruction<
+  TAccountSolver extends string,
+  TAccountOrder extends string,
+  TAccountGuard extends string,
+  TAccountIxSysvar extends string,
+  TAccountStablecoinTokenMint extends string,
+  TAccountSolverStablecoinTokenAccount extends string,
+  TAccountGuardStablecoinTokenAccount extends string,
+  TAccountStablecoinTokenProgram extends string,
+  TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
+>(
+  input: StartDcaOrderExecutionAfterSwapInput<
+    TAccountSolver,
+    TAccountOrder,
+    TAccountGuard,
+    TAccountIxSysvar,
+    TAccountStablecoinTokenMint,
+    TAccountSolverStablecoinTokenAccount,
+    TAccountGuardStablecoinTokenAccount,
+    TAccountStablecoinTokenProgram
+  >,
+  config?: { programAddress?: TProgramAddress }
+): StartDcaOrderExecutionAfterSwapInstruction<
+  TProgramAddress,
+  TAccountSolver,
+  TAccountOrder,
+  TAccountGuard,
+  TAccountIxSysvar,
+  TAccountStablecoinTokenMint,
+  TAccountSolverStablecoinTokenAccount,
+  TAccountGuardStablecoinTokenAccount,
+  TAccountStablecoinTokenProgram
+> {
+  // Program address.
+  const programAddress = config?.programAddress ?? SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    solver: { value: input.solver ?? null, isWritable: true },
+    order: { value: input.order ?? null, isWritable: true },
+    guard: { value: input.guard ?? null, isWritable: false },
+    ixSysvar: { value: input.ixSysvar ?? null, isWritable: false },
+    stablecoinTokenMint: { value: input.stablecoinTokenMint ?? null, isWritable: false },
+    solverStablecoinTokenAccount: {
+      value: input.solverStablecoinTokenAccount ?? null,
+      isWritable: true,
+    },
+    guardStablecoinTokenAccount: {
+      value: input.guardStablecoinTokenAccount ?? null,
+      isWritable: true,
+    },
+    stablecoinTokenProgram: { value: input.stablecoinTokenProgram ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedAccount>;
+
+  // Original args.
+  const args = { ...input };
+
+  // Resolve default values.
+  if (!accounts.ixSysvar.value) {
+    accounts.ixSysvar.value =
+      'Sysvar1nstructions1111111111111111111111111' as Address<'Sysvar1nstructions1111111111111111111111111'>;
+  }
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.solver),
+      getAccountMeta(accounts.order),
+      getAccountMeta(accounts.guard),
+      getAccountMeta(accounts.ixSysvar),
+      getAccountMeta(accounts.stablecoinTokenMint),
+      getAccountMeta(accounts.solverStablecoinTokenAccount),
+      getAccountMeta(accounts.guardStablecoinTokenAccount),
+      getAccountMeta(accounts.stablecoinTokenProgram),
+    ],
+    programAddress,
+    data: getStartDcaOrderExecutionAfterSwapInstructionDataEncoder().encode(
+      args as StartDcaOrderExecutionAfterSwapInstructionDataArgs
+    ),
+  } as StartDcaOrderExecutionAfterSwapInstruction<
+    TProgramAddress,
+    TAccountSolver,
+    TAccountOrder,
+    TAccountGuard,
+    TAccountIxSysvar,
+    TAccountStablecoinTokenMint,
+    TAccountSolverStablecoinTokenAccount,
+    TAccountGuardStablecoinTokenAccount,
+    TAccountStablecoinTokenProgram
+  >;
+
+  return instruction;
+}
+
+export type ParsedStartDcaOrderExecutionAfterSwapInstruction<
+  TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
+  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+  programAddress: Address<TProgram>;
+  accounts: {
+    /** Solver that starts DCA order execution */
+    solver: TAccountMetas[0];
+    /** DCA order data */
+    order: TAccountMetas[1];
+    /** Guard address, that protects this DCA order execution */
+    guard: TAccountMetas[2];
+    /**
+     * the supplied Sysvar could be anything else.
+     * The Instruction Sysvar has not been implemented
+     * in the Anchor framework yet, so this is the safe approach.
+     */
+
+    ixSysvar: TAccountMetas[3];
+    /** Stablecoin token mint */
+    stablecoinTokenMint: TAccountMetas[4];
+    /**
+     * Solver stablecoin account, from which solver is paying stablecoin tokens
+     * after swapping Tokens IN
+     */
+
+    solverStablecoinTokenAccount: TAccountMetas[5];
+    /** Guard stablecoin account, where Guard is collecting stablecoins */
+    guardStablecoinTokenAccount: TAccountMetas[6];
+    /** Solana token program */
+    stablecoinTokenProgram: TAccountMetas[7];
+  };
+  data: StartDcaOrderExecutionAfterSwapInstructionData;
+};
+
+export function parseStartDcaOrderExecutionAfterSwapInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly AccountMeta[],
+>(
+  instruction: Instruction<TProgram> &
+    InstructionWithAccounts<TAccountMetas> &
+    InstructionWithData<ReadonlyUint8Array>
+): ParsedStartDcaOrderExecutionAfterSwapInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 8) {
+    // TODO: Coded error.
+    throw new Error('Not enough accounts');
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      solver: getNextAccount(),
+      order: getNextAccount(),
+      guard: getNextAccount(),
+      ixSysvar: getNextAccount(),
+      stablecoinTokenMint: getNextAccount(),
+      solverStablecoinTokenAccount: getNextAccount(),
+      guardStablecoinTokenAccount: getNextAccount(),
+      stablecoinTokenProgram: getNextAccount(),
+    },
+    data: getStartDcaOrderExecutionAfterSwapInstructionDataDecoder().decode(instruction.data),
+  };
+}

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

@@ -17,15 +17,20 @@ import {
   type ParsedAcceptAdminInstruction,
   type ParsedCancelDcaOrderInstruction,
   type ParsedCancelOrderInstruction,
+  type ParsedClaimTokensForDcaIntervalInstruction,
   type ParsedClaimTokensInstruction,
   type ParsedCollectProtocolFeesInstruction,
   type ParsedCreateDcaOrderInstruction,
   type ParsedCreateGuardInstruction,
   type ParsedCreateOrderInstruction,
   type ParsedInitializeInstruction,
+  type ParsedPreStartDcaOrderExecutionInstruction,
   type ParsedPreStartOrderExecutionInstruction,
   type ParsedSetAdminInstruction,
   type ParsedSetAuctioneerPubKeyInstruction,
+  type ParsedSetCancelAuthoritiesInstruction,
+  type ParsedStartDcaOrderExecutionAfterSwapInstruction,
+  type ParsedStartDcaOrderExecutionInstruction,
   type ParsedStartOrderExecutionAfterSwapInstruction,
   type ParsedStartOrderExecutionInstruction,
 } from '../instructions/index.js';
@@ -96,14 +101,19 @@ export enum SourceChainGuardInstruction {
   CancelDcaOrder,
   CancelOrder,
   ClaimTokens,
+  ClaimTokensForDcaInterval,
   CollectProtocolFees,
   CreateDcaOrder,
   CreateGuard,
   CreateOrder,
   Initialize,
+  PreStartDcaOrderExecution,
   PreStartOrderExecution,
   SetAdmin,
   SetAuctioneerPubKey,
+  SetCancelAuthorities,
+  StartDcaOrderExecution,
+  StartDcaOrderExecutionAfterSwap,
   StartOrderExecution,
   StartOrderExecutionAfterSwap,
 }
@@ -156,6 +166,17 @@ export function identifySourceChainGuardInstruction(
   ) {
     return SourceChainGuardInstruction.ClaimTokens;
   }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([166, 78, 207, 111, 247, 63, 107, 46])
+      ),
+      0
+    )
+  ) {
+    return SourceChainGuardInstruction.ClaimTokensForDcaInterval;
+  }
   if (
     containsBytes(
       data,
@@ -211,6 +232,17 @@ export function identifySourceChainGuardInstruction(
   ) {
     return SourceChainGuardInstruction.Initialize;
   }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([79, 13, 106, 110, 71, 32, 11, 248])
+      ),
+      0
+    )
+  ) {
+    return SourceChainGuardInstruction.PreStartDcaOrderExecution;
+  }
   if (
     containsBytes(
       data,
@@ -244,6 +276,39 @@ export function identifySourceChainGuardInstruction(
   ) {
     return SourceChainGuardInstruction.SetAuctioneerPubKey;
   }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([14, 52, 221, 74, 176, 141, 238, 71])
+      ),
+      0
+    )
+  ) {
+    return SourceChainGuardInstruction.SetCancelAuthorities;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([0, 61, 163, 212, 122, 175, 14, 47])
+      ),
+      0
+    )
+  ) {
+    return SourceChainGuardInstruction.StartDcaOrderExecution;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([30, 107, 27, 130, 23, 22, 101, 198])
+      ),
+      0
+    )
+  ) {
+    return SourceChainGuardInstruction.StartDcaOrderExecutionAfterSwap;
+  }
   if (
     containsBytes(
       data,
@@ -286,6 +351,9 @@ export type ParsedSourceChainGuardInstruction<
   | ({
       instructionType: SourceChainGuardInstruction.ClaimTokens;
     } & ParsedClaimTokensInstruction<TProgram>)
+  | ({
+      instructionType: SourceChainGuardInstruction.ClaimTokensForDcaInterval;
+    } & ParsedClaimTokensForDcaIntervalInstruction<TProgram>)
   | ({
       instructionType: SourceChainGuardInstruction.CollectProtocolFees;
     } & ParsedCollectProtocolFeesInstruction<TProgram>)
@@ -301,6 +369,9 @@ export type ParsedSourceChainGuardInstruction<
   | ({
       instructionType: SourceChainGuardInstruction.Initialize;
     } & ParsedInitializeInstruction<TProgram>)
+  | ({
+      instructionType: SourceChainGuardInstruction.PreStartDcaOrderExecution;
+    } & ParsedPreStartDcaOrderExecutionInstruction<TProgram>)
   | ({
       instructionType: SourceChainGuardInstruction.PreStartOrderExecution;
     } & ParsedPreStartOrderExecutionInstruction<TProgram>)
@@ -310,6 +381,15 @@ export type ParsedSourceChainGuardInstruction<
   | ({
       instructionType: SourceChainGuardInstruction.SetAuctioneerPubKey;
     } & ParsedSetAuctioneerPubKeyInstruction<TProgram>)
+  | ({
+      instructionType: SourceChainGuardInstruction.SetCancelAuthorities;
+    } & ParsedSetCancelAuthoritiesInstruction<TProgram>)
+  | ({
+      instructionType: SourceChainGuardInstruction.StartDcaOrderExecution;
+    } & ParsedStartDcaOrderExecutionInstruction<TProgram>)
+  | ({
+      instructionType: SourceChainGuardInstruction.StartDcaOrderExecutionAfterSwap;
+    } & ParsedStartDcaOrderExecutionAfterSwapInstruction<TProgram>)
   | ({
       instructionType: SourceChainGuardInstruction.StartOrderExecution;
     } & ParsedStartOrderExecutionInstruction<TProgram>)

package/src/core/solana/generated/cross-chain/types/cancelAuthoritiesUpdated.ts

@@ -0,0 +1,40 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  getAddressDecoder,
+  getAddressEncoder,
+  getArrayDecoder,
+  getArrayEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Address,
+  type Codec,
+  type Decoder,
+  type Encoder,
+} from '@solana/kit';
+
+export type CancelAuthoritiesUpdated = { newCancelAuthorities: Array<Address> };
+
+export type CancelAuthoritiesUpdatedArgs = CancelAuthoritiesUpdated;
+
+export function getCancelAuthoritiesUpdatedEncoder(): Encoder<CancelAuthoritiesUpdatedArgs> {
+  return getStructEncoder([['newCancelAuthorities', getArrayEncoder(getAddressEncoder())]]);
+}
+
+export function getCancelAuthoritiesUpdatedDecoder(): Decoder<CancelAuthoritiesUpdated> {
+  return getStructDecoder([['newCancelAuthorities', getArrayDecoder(getAddressDecoder())]]);
+}
+
+export function getCancelAuthoritiesUpdatedCodec(): Codec<
+  CancelAuthoritiesUpdatedArgs,
+  CancelAuthoritiesUpdated
+> {
+  return combineCodec(getCancelAuthoritiesUpdatedEncoder(), getCancelAuthoritiesUpdatedDecoder());
+}

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

@@ -9,6 +9,7 @@
 export * from './adminUpdated.js';
 export * from './adminUpdateStarted.js';
 export * from './auctioneerPubkeyUpdated.js';
+export * from './cancelAuthoritiesUpdated.js';
 export * from './dcaExecutionStarted.js';
 export * from './dcaOrderCreated.js';
 export * from './dcaOrderIntervalFulfilled.js';

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

@@ -24,6 +24,8 @@ import {
   combineCodec,
   fixDecoderSize,
   fixEncoderSize,
+  getArrayDecoder,
+  getArrayEncoder,
   getBytesDecoder,
   getBytesEncoder,
   getStructDecoder,
@@ -33,9 +35,9 @@ import {
   getU8Decoder,
   getU8Encoder,
   transformEncoder,
-  type FixedSizeCodec,
-  type FixedSizeDecoder,
-  type FixedSizeEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
   type ReadonlyUint8Array,
 } from '@solana/codecs';
 
@@ -57,6 +59,12 @@ export type Guard = {
   auctioneerPubKey: Address;
   /** Amount of collected fees, in collateral tokens */
   collectedFees: bigint;
+  /**
+   * List of wallets that can cancel user orders. They will be authorized by Admin
+   * and used to enhance UX, allowing to avoid paying gas for order cancellation and
+   * tokens recovery
+   */
+  cancelAuthorities: Array<Address>;
 };
 
 export type GuardArgs = {
@@ -70,9 +78,15 @@ export type GuardArgs = {
   auctioneerPubKey: Address;
   /** Amount of collected fees, in collateral tokens */
   collectedFees: number | bigint;
+  /**
+   * List of wallets that can cancel user orders. They will be authorized by Admin
+   * and used to enhance UX, allowing to avoid paying gas for order cancellation and
+   * tokens recovery
+   */
+  cancelAuthorities: Array<Address>;
 };
 
-export function getGuardEncoder(): FixedSizeEncoder<GuardArgs> {
+export function getGuardEncoder(): Encoder<GuardArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
@@ -81,12 +95,13 @@ export function getGuardEncoder(): FixedSizeEncoder<GuardArgs> {
       ['bump', getU8Encoder()],
       ['auctioneerPubKey', getAddressEncoder()],
       ['collectedFees', getU64Encoder()],
+      ['cancelAuthorities', getArrayEncoder(getAddressEncoder())],
     ]),
     (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR })
   );
 }
 
-export function getGuardDecoder(): FixedSizeDecoder<Guard> {
+export function getGuardDecoder(): Decoder<Guard> {
   return getStructDecoder([
     ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
     ['feeToken', getAddressDecoder()],
@@ -94,10 +109,11 @@ export function getGuardDecoder(): FixedSizeDecoder<Guard> {
     ['bump', getU8Decoder()],
     ['auctioneerPubKey', getAddressDecoder()],
     ['collectedFees', getU64Decoder()],
+    ['cancelAuthorities', getArrayDecoder(getAddressDecoder())],
   ]);
 }
 
-export function getGuardCodec(): FixedSizeCodec<GuardArgs, Guard> {
+export function getGuardCodec(): Codec<GuardArgs, Guard> {
   return combineCodec(getGuardEncoder(), getGuardDecoder());
 }
 
@@ -150,7 +166,3 @@ export async function fetchAllMaybeGuard(
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));
 }
-
-export function getGuardSize(): number {
-  return 82;
-}