@shogun-sdk/intents-sdk 1.3.0 → 1.4.0

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

@@ -1,32 +1,29 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { keccak256 } from "js-sha3";
-import type { ExtraTransfer } from "./single-chain-limit-order.js";
-
+import { BN } from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+import type { ExtraTransfer } from './single-chain-limit-order.js';
+import pkg from 'js-sha3';
+const { keccak256 } = pkg;
 /**
  * Generate secret number and prepare secret hash for single chain DCA orders
  * @param tokenOut Token OUT Pubkey
  * @param receiver Token OUT receiver Pubkey
  * @param extraTransfers Requested extra transfers
  */
-export function prepareDcaSecretData(
-  tokenOut: PublicKey,
-  receiver: PublicKey,
-  extraTransfers: ExtraTransfer[],
-) {
+export function prepareDcaSecretData(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'
-  ))];
+  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 };
 }

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

@@ -1,6 +1,7 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import { keccak256 } from "js-sha3";
+import { BN } from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+import pkg from 'js-sha3';
+const { keccak256 } = pkg;
 
 export type ExtraTransfer = {
   token: PublicKey;
@@ -14,31 +15,28 @@ export type ExtraTransfer = {
  * @param receiver Token OUT receiver Pubkey
  * @param extraTransfers Requested extra transfers
  */
-export function prepareSecretData(
-  tokenOut: PublicKey,
-  receiver: PublicKey,
-  extraTransfers: ExtraTransfer[],
-) {
+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'
-  ))];
+  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
+  if (token.equals(new PublicKey('So11111111111111111111111111111111111111111'))) {
+    return PublicKey.default;
   }
 
   return token;

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

@@ -88,7 +88,7 @@ export type DcaOrder = {
   intervalIndexOfLatestExecutionStart: number;
   /** Total number of already executed intervals */
   totalExecutedIntervals: number;
-  /** INDEX of last executed interval */
+  /** INDEX of last successfully fulfilled interval */
   lastExecutedIntervalIndex: number;
 };
 
@@ -132,7 +132,7 @@ export type DcaOrderArgs = {
   intervalIndexOfLatestExecutionStart: number;
   /** Total number of already executed intervals */
   totalExecutedIntervals: number;
-  /** INDEX of last executed interval */
+  /** INDEX of last successfully fulfilled interval */
   lastExecutedIntervalIndex: number;
 };
 

package/src/core/solana/generated/cross-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';
 
@@ -59,6 +61,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 = {
@@ -74,9 +82,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)],
@@ -86,12 +100,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)],
     ['collateralToken', getAddressDecoder()],
@@ -100,10 +115,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());
 }
 
@@ -156,7 +172,3 @@ export async function fetchAllMaybeGuard(
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));
 }
-
-export function getGuardSize(): number {
-  return 114;
-}

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

@@ -21,72 +21,74 @@ export const SOURCE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN = 0x1772; // 6002
 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
+/** NotAUserOrCancelAuthority: Account is not a User or Cancel authority */
+export const SOURCE_CHAIN_GUARD_ERROR__NOT_A_USER_OR_CANCEL_AUTHORITY = 0x1775; // 6005
 /** ZeroAmount: Amount must not be zero */
-export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT = 0x1775; // 6005
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT = 0x1776; // 6006
 /** ZeroAmountIn: Amount IN must not be zero */
-export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN = 0x1776; // 6006
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN = 0x1777; // 6007
 /** ZeroMinStablecoins: Min stablecoins amount must not be zero */
-export const SOURCE_CHAIN_GUARD_ERROR__ZERO_MIN_STABLECOINS = 0x1777; // 6007
+export const SOURCE_CHAIN_GUARD_ERROR__ZERO_MIN_STABLECOINS = 0x1778; // 6008
 /** WrongOrder: Wrong order */
-export const SOURCE_CHAIN_GUARD_ERROR__WRONG_ORDER = 0x1778; // 6008
+export const SOURCE_CHAIN_GUARD_ERROR__WRONG_ORDER = 0x1779; // 6009
 /** InvalidGuard: Invalid Guard */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_GUARD = 0x1779; // 6009
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_GUARD = 0x177a; // 6010
 /** ExpiredDeadline: Expired deadline */
-export const SOURCE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE = 0x177a; // 6010
+export const SOURCE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE = 0x177b; // 6011
 /** InvalidStartPermission: Invalid permission */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION = 0x177b; // 6011
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION = 0x177c; // 6012
 /** InvalidSuccessConfirmation: Invalid success confirmation */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SUCCESS_CONFIRMATION = 0x177c; // 6012
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SUCCESS_CONFIRMATION = 0x177d; // 6013
 /** OrderIsBeingExecuted: Order is being executed */
-export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_BEING_EXECUTED = 0x177d; // 6013
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_BEING_EXECUTED = 0x177e; // 6014
 /** InvalidRecoverToken: Invalid recover token */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_RECOVER_TOKEN = 0x177e; // 6014
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_RECOVER_TOKEN = 0x177f; // 6015
 /** AccountNotProvided: Account not provided */
-export const SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED = 0x177f; // 6015
+export const SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED = 0x1780; // 6016
 /** CpiCallNotAllowed: CPI call is not allowed */
-export const SOURCE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED = 0x1780; // 6016
+export const SOURCE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED = 0x1781; // 6017
 /** FeeTransferNotAllowed: Fee transfer not allowed */
-export const SOURCE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED = 0x1781; // 6017
+export const SOURCE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED = 0x1782; // 6018
 /** InvalidIntervalDuration: Invalid interval duration */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION = 0x1782; // 6018
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION = 0x1783; // 6019
 /** SwapNotAllowed: Swap is not allowed */
-export const SOURCE_CHAIN_GUARD_ERROR__SWAP_NOT_ALLOWED = 0x1783; // 6019
+export const SOURCE_CHAIN_GUARD_ERROR__SWAP_NOT_ALLOWED = 0x1784; // 6020
 /** NoAfterSwapInstructionFound: No _after_swap instruction found */
-export const SOURCE_CHAIN_GUARD_ERROR__NO_AFTER_SWAP_INSTRUCTION_FOUND = 0x1784; // 6020
+export const SOURCE_CHAIN_GUARD_ERROR__NO_AFTER_SWAP_INSTRUCTION_FOUND = 0x1785; // 6021
 /** InvalidAfterSwapInstruction: Invalid _after_swap instruction */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_AFTER_SWAP_INSTRUCTION = 0x1785; // 6021
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_AFTER_SWAP_INSTRUCTION = 0x1786; // 6022
 /** AlreadySwapped: Tokens IN were already swapped */
-export const SOURCE_CHAIN_GUARD_ERROR__ALREADY_SWAPPED = 0x1786; // 6022
+export const SOURCE_CHAIN_GUARD_ERROR__ALREADY_SWAPPED = 0x1787; // 6023
 /** SwapWasNotInitiated: Swap wasn't initiated */
-export const SOURCE_CHAIN_GUARD_ERROR__SWAP_WAS_NOT_INITIATED = 0x1787; // 6023
+export const SOURCE_CHAIN_GUARD_ERROR__SWAP_WAS_NOT_INITIATED = 0x1788; // 6024
 /** BelowMinStablecoinsAmount: Below minimum stablecoins amount */
-export const SOURCE_CHAIN_GUARD_ERROR__BELOW_MIN_STABLECOINS_AMOUNT = 0x1788; // 6024
+export const SOURCE_CHAIN_GUARD_ERROR__BELOW_MIN_STABLECOINS_AMOUNT = 0x1789; // 6025
 /** CollateralTokenAccountsNotProvided: Collateral token accounts not provided */
-export const SOURCE_CHAIN_GUARD_ERROR__COLLATERAL_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x1789; // 6025
+export const SOURCE_CHAIN_GUARD_ERROR__COLLATERAL_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x178a; // 6026
 /** StablecoinAccountsNotProvided: Stablecoin accounts not provided */
-export const SOURCE_CHAIN_GUARD_ERROR__STABLECOIN_ACCOUNTS_NOT_PROVIDED = 0x178a; // 6026
+export const SOURCE_CHAIN_GUARD_ERROR__STABLECOIN_ACCOUNTS_NOT_PROVIDED = 0x178b; // 6027
 /** RecoverTokenAccountsNotProvided: Recover token accounts not provided */
-export const SOURCE_CHAIN_GUARD_ERROR__RECOVER_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x178b; // 6027
+export const SOURCE_CHAIN_GUARD_ERROR__RECOVER_TOKEN_ACCOUNTS_NOT_PROVIDED = 0x178c; // 6028
 /** InvalidDestTokenAccount: Invalid dest token account */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DEST_TOKEN_ACCOUNT = 0x178c; // 6028
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DEST_TOKEN_ACCOUNT = 0x178d; // 6029
 /** OrderIsCancelled: Order is cancelled */
-export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_CANCELLED = 0x178d; // 6029
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_CANCELLED = 0x178e; // 6030
 /** OrderIsFulfilled: Order is fulfilled */
-export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_FULFILLED = 0x178e; // 6030
+export const SOURCE_CHAIN_GUARD_ERROR__ORDER_IS_FULFILLED = 0x178f; // 6031
 /** InvalidDcaOrder: Invalid DCA order */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER = 0x178f; // 6031
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER = 0x1790; // 6032
 /** IntervalWasAlreadyClaimed: Interval was already claimed */
-export const SOURCE_CHAIN_GUARD_ERROR__INTERVAL_WAS_ALREADY_CLAIMED = 0x1790; // 6032
+export const SOURCE_CHAIN_GUARD_ERROR__INTERVAL_WAS_ALREADY_CLAIMED = 0x1791; // 6033
 /** CantStartOrderExecutionDuringThisInterval: Cant start order execution during this interval */
-export const SOURCE_CHAIN_GUARD_ERROR__CANT_START_ORDER_EXECUTION_DURING_THIS_INTERVAL = 0x1791; // 6033
+export const SOURCE_CHAIN_GUARD_ERROR__CANT_START_ORDER_EXECUTION_DURING_THIS_INTERVAL = 0x1792; // 6034
 /** PreviousIntervalCollateralTokenAccountNotProvided: Previous interval collateral token account not provided */
-export const SOURCE_CHAIN_GUARD_ERROR__PREVIOUS_INTERVAL_COLLATERAL_TOKEN_ACCOUNT_NOT_PROVIDED = 0x1792; // 6034
+export const SOURCE_CHAIN_GUARD_ERROR__PREVIOUS_INTERVAL_COLLATERAL_TOKEN_ACCOUNT_NOT_PROVIDED = 0x1793; // 6035
 /** InstructionNotFound: Ed25519Program instruction */
-export const SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND = 0x1793; // 6035
+export const SOURCE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND = 0x1794; // 6036
 /** SigVerificationFailed: Signature verification failed */
-export const SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED = 0x1794; // 6036
+export const SOURCE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED = 0x1795; // 6037
 /** InvalidSigner: Invalid signer */
-export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER = 0x1795; // 6037
+export const SOURCE_CHAIN_GUARD_ERROR__INVALID_SIGNER = 0x1796; // 6038
 
 export type SourceChainGuardError =
   | typeof SOURCE_CHAIN_GUARD_ERROR__ACCOUNT_NOT_PROVIDED
@@ -112,6 +114,7 @@ export type SourceChainGuardError =
   | 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_A_USER_OR_CANCEL_AUTHORITY
   | 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
@@ -154,6 +157,7 @@ if (process.env.NODE_ENV !== 'production') {
     [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_A_USER_OR_CANCEL_AUTHORITY]: `Account is not a User or Cancel authority`,
     [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`,

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

@@ -44,6 +44,7 @@ export function getCancelDcaOrderDiscriminatorBytes() {
 
 export type CancelDcaOrderInstruction<
   TProgram extends string = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
+  TAccountSigner extends string | AccountMeta<string> = string,
   TAccountUser extends string | AccountMeta<string> = string,
   TAccountOrder extends string | AccountMeta<string> = string,
   TAccountGuard extends string | AccountMeta<string> = string,
@@ -64,9 +65,10 @@ export type CancelDcaOrderInstruction<
   InstructionWithData<ReadonlyUint8Array> &
   InstructionWithAccounts<
     [
-      TAccountUser extends string
-        ? WritableSignerAccount<TAccountUser> & AccountSignerMeta<TAccountUser>
-        : TAccountUser,
+      TAccountSigner extends string
+        ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner>
+        : TAccountSigner,
+      TAccountUser extends string ? WritableAccount<TAccountUser> : TAccountUser,
       TAccountOrder extends string ? WritableAccount<TAccountOrder> : TAccountOrder,
       TAccountGuard extends string ? ReadonlyAccount<TAccountGuard> : TAccountGuard,
       TAccountTokenInMint extends string
@@ -135,6 +137,7 @@ export function getCancelDcaOrderInstructionDataCodec(): FixedSizeCodec<
 }
 
 export type CancelDcaOrderInput<
+  TAccountSigner extends string = string,
   TAccountUser extends string = string,
   TAccountOrder extends string = string,
   TAccountGuard extends string = string,
@@ -151,8 +154,10 @@ export type CancelDcaOrderInput<
   TAccountGuardCollateralTokenAccount extends string = string,
   TAccountCollateralTokenProgram extends string = string,
 > = {
-  /** User that is order creator which wants to cancel the order */
-  user: TransactionSigner<TAccountUser>;
+  /** Either user or cancel authority */
+  signer: TransactionSigner<TAccountSigner>;
+  /** User account that will receive lamports after closing Order account */
+  user: Address<TAccountUser>;
   /** DCA order data */
   order: Address<TAccountOrder>;
   /** Guard address, that protects this DCA order execution */
@@ -190,6 +195,7 @@ export type CancelDcaOrderInput<
 };
 
 export function getCancelDcaOrderInstruction<
+  TAccountSigner extends string,
   TAccountUser extends string,
   TAccountOrder extends string,
   TAccountGuard extends string,
@@ -208,6 +214,7 @@ export function getCancelDcaOrderInstruction<
   TProgramAddress extends Address = typeof SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
 >(
   input: CancelDcaOrderInput<
+    TAccountSigner,
     TAccountUser,
     TAccountOrder,
     TAccountGuard,
@@ -227,6 +234,7 @@ export function getCancelDcaOrderInstruction<
   config?: { programAddress?: TProgramAddress }
 ): CancelDcaOrderInstruction<
   TProgramAddress,
+  TAccountSigner,
   TAccountUser,
   TAccountOrder,
   TAccountGuard,
@@ -248,6 +256,7 @@ export function getCancelDcaOrderInstruction<
 
   // Original accounts.
   const originalAccounts = {
+    signer: { value: input.signer ?? null, isWritable: true },
     user: { value: input.user ?? null, isWritable: true },
     order: { value: input.order ?? null, isWritable: true },
     guard: { value: input.guard ?? null, isWritable: false },
@@ -275,6 +284,7 @@ export function getCancelDcaOrderInstruction<
   const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
   const instruction = {
     accounts: [
+      getAccountMeta(accounts.signer),
       getAccountMeta(accounts.user),
       getAccountMeta(accounts.order),
       getAccountMeta(accounts.guard),
@@ -295,6 +305,7 @@ export function getCancelDcaOrderInstruction<
     data: getCancelDcaOrderInstructionDataEncoder().encode({}),
   } as CancelDcaOrderInstruction<
     TProgramAddress,
+    TAccountSigner,
     TAccountUser,
     TAccountOrder,
     TAccountGuard,
@@ -321,44 +332,46 @@ export type ParsedCancelDcaOrderInstruction<
 > = {
   programAddress: Address<TProgram>;
   accounts: {
-    /** User that is order creator which wants to cancel the order */
-    user: TAccountMetas[0];
+    /** Either user or cancel authority */
+    signer: TAccountMetas[0];
+    /** User account that will receive lamports after closing Order account */
+    user: TAccountMetas[1];
     /** DCA order data */
-    order: TAccountMetas[1];
+    order: TAccountMetas[2];
     /** Guard address, that protects this DCA order execution */
-    guard: TAccountMetas[2];
+    guard: TAccountMetas[3];
     /** Token IN mint */
-    tokenInMint: TAccountMetas[3];
+    tokenInMint: TAccountMetas[4];
     /** User token IN account to which remaining tokens IN will be sent. */
-    userTokenInAccount: TAccountMetas[4];
+    userTokenInAccount: TAccountMetas[5];
     /** Guard token IN account from which remaining tokens IN will be sent to the user */
-    guardTokenInAccount: TAccountMetas[5];
+    guardTokenInAccount: TAccountMetas[6];
     /** Token IN program */
-    tokenInProgram: TAccountMetas[6];
+    tokenInProgram: TAccountMetas[7];
     /** Stablecoin mint */
-    stablecoinMint?: TAccountMetas[7] | undefined;
+    stablecoinMint?: TAccountMetas[8] | undefined;
     /**
      * User stablecoin account to which remaining stablecoins (if tokens IN were swapped)
      * will be sent.
      */
 
-    userStablecoinAccount?: TAccountMetas[8] | undefined;
+    userStablecoinAccount?: TAccountMetas[9] | undefined;
     /**
      * Guard stablecoins account from which stablecoins (if tokens IN were swapped)
      * will be sent.
      */
 
-    guardStablecoinAccount?: TAccountMetas[9] | undefined;
+    guardStablecoinAccount?: TAccountMetas[10] | undefined;
     /** Stablecoin program */
-    stablecoinProgram?: TAccountMetas[10] | undefined;
+    stablecoinProgram?: TAccountMetas[11] | undefined;
     /** Collateral token mint */
-    collateralTokenMint?: TAccountMetas[11] | undefined;
+    collateralTokenMint?: TAccountMetas[12] | undefined;
     /** User collateral token account to which collateral tokens (if any) will be sent. */
-    userCollateralTokenAccount?: TAccountMetas[12] | undefined;
+    userCollateralTokenAccount?: TAccountMetas[13] | undefined;
     /** Guard collateral token account from which collateral tokens (if any) will be sent. */
-    guardCollateralTokenAccount?: TAccountMetas[13] | undefined;
+    guardCollateralTokenAccount?: TAccountMetas[14] | undefined;
     /** Solana token program */
-    collateralTokenProgram?: TAccountMetas[14] | undefined;
+    collateralTokenProgram?: TAccountMetas[15] | undefined;
   };
   data: CancelDcaOrderInstructionData;
 };
@@ -371,7 +384,7 @@ export function parseCancelDcaOrderInstruction<
     InstructionWithAccounts<TAccountMetas> &
     InstructionWithData<ReadonlyUint8Array>
 ): ParsedCancelDcaOrderInstruction<TProgram, TAccountMetas> {
-  if (instruction.accounts.length < 15) {
+  if (instruction.accounts.length < 16) {
     // TODO: Coded error.
     throw new Error('Not enough accounts');
   }
@@ -388,6 +401,7 @@ export function parseCancelDcaOrderInstruction<
   return {
     programAddress: instruction.programAddress,
     accounts: {
+      signer: getNextAccount(),
       user: getNextAccount(),
       order: getNextAccount(),
       guard: getNextAccount(),