@shogun-sdk/intents-sdk 1.3.0 → 1.4.1

package/src/core/orders/cross-chain.ts

@@ -10,7 +10,7 @@ import {
 } from '../../types/intent.js';
 import { CrossChainOrderValidator } from '../../utils/order-validator.js';
 import { Parsers } from '../../utils/parsers.js';
-import { type ExtraTransfer } from './common.js';
+import { type ExtraTransfer, type StopLossType } from './common.js';
 import type { ApiResponse } from '../../types/api.js';
 import { BaseSDK } from '../sdk.js';
 import { getEVMCrossChainOrderTypedData } from '../evm/order-signature.js';
@@ -40,8 +40,9 @@ export type CreateCrossChainOrderParams = {
   /** Extra transfers to be made */
   extraTransfers?: ExtraTransfer[];
 
-  /** Stop loss max out */
-  stopLossMaxOut?: bigint;
+  /** Stop loss */
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   /** Take profit min out */
   takeProfitMinOut?: bigint;
 };
@@ -73,8 +74,9 @@ export class CrossChainOrder {
   public deadline: number;
   /** Extra transfers to be made */
   public extraTransfers?: ExtraTransfer[];
-  /** Stop loss max out */
-  public stopLossMaxOut?: bigint;
+  /** Stop loss */
+  public stopLossType?: StopLossType;
+  public stopLossTriggerPrice?: string;
   /** Take profit min out */
   public takeProfitMinOut?: bigint;
 
@@ -90,7 +92,8 @@ export class CrossChainOrder {
     this.minStablecoinAmount = params.minStablecoinAmount ?? 1n;
     this.deadline = params.deadline;
     this.extraTransfers = params.extraTransfers;
-    this.stopLossMaxOut = params.stopLossMaxOut;
+    this.stopLossType = params.stopLossType;
+    this.stopLossTriggerPrice = params.stopLossTriggerPrice;
     this.takeProfitMinOut = params.takeProfitMinOut;
   }
 
@@ -154,15 +157,16 @@ export class CrossChainOrder {
   private static async calculateAmountOutMin(
     input: CreateCrossChainOrderParams,
   ): Promise<{ minStablecoinAmount: bigint; destinationTokenMinAmount: bigint }> {
-    const { destinationTokenMinAmount, stopLossMaxOut, minStablecoinAmount } = input;
+    const { destinationTokenMinAmount, stopLossType, stopLossTriggerPrice, minStablecoinAmount } = input;
 
-    if (stopLossMaxOut !== undefined) {
+    if (stopLossType !== undefined && stopLossTriggerPrice !== undefined) {
       return {
         destinationTokenMinAmount: 1n,
         minStablecoinAmount: 1n,
       };
     }
 
+    // TODO: Change this
     if (!minStablecoinAmount || !destinationTokenMinAmount) {
       const quote = await QuoteProvider.getQuote({
         sourceChainId: input.sourceChainId,
@@ -196,6 +200,9 @@ export class CrossChainOrder {
       destinationAddress: this.destinationAddress,
       amountOutMin: this.destinationTokenMinAmount,
       extraTransfers: this.extraTransfers,
+      stopLossType: this.stopLossType,
+      stopLossTriggerPrice: this.stopLossTriggerPrice,
+      takeProfitMinOut: this.takeProfitMinOut,
     };
   }
 

package/src/core/orders/single-chain.ts

@@ -4,10 +4,13 @@ import type { ApiResponse } from '../../types/api.js';
 import type { SingleChainPreparedData, SingleChainUserIntentRequest } from '../../types/intent.js';
 import { SingleChainOrderValidator } from '../../utils/order-validator.js';
 import { QuoteProvider } from '../../utils/quote/aggregator.js';
+import { estimateAmountOut } from '../../utils/quote/pricing/estimate-amount-out.js';
+import { estimateExpensesInTokenOut } from '../../utils/quote/pricing/expenses.js';
+import { DEFAULT_COMMISSION_BPS, EVM_SINGLE_CHAIN_GAS_LIMIT, SINGLE_CHAIN_COMMISSION_DENOMINATOR } from '../../utils/quote/pricing/constants.js';
 import { getEVMSingleChainOrderTypedData } from '../evm/order-signature.js';
 import { BaseSDK } from '../sdk.js';
 import { getSolanaSingleChainOrderInstructions } from '../solana/order-instructions.js';
-import { type ExtraTransfer } from './common.js';
+import { type ExtraTransfer, type StopLossType } from './common.js';
 
 export type CreateSingleChainOrderParams = {
   chainId: SupportedChain;
@@ -19,7 +22,8 @@ export type CreateSingleChainOrderParams = {
   extraTransfers?: ExtraTransfer[];
   deadline: number;
 
-  stopLossMaxOut?: bigint;
+  stopLossType?: StopLossType;
+  stopLossTriggerPrice?: string;
   takeProfitMinOut?: bigint;
 };
 
@@ -35,7 +39,8 @@ export class SingleChainOrder {
   public destinationAddress: string;
   public extraTransfers?: ExtraTransfer[];
   public deadline: number;
-  public stopLossMaxOut?: bigint;
+  public stopLossType?: StopLossType;
+  public stopLossTriggerPrice?: string;
   public takeProfitMinOut?: bigint;
 
   private constructor(params: CreateSingleChainOrderParams & { user: string }) {
@@ -48,7 +53,8 @@ export class SingleChainOrder {
     this.destinationAddress = params.destinationAddress;
     this.extraTransfers = params.extraTransfers;
     this.deadline = params.deadline;
-    this.stopLossMaxOut = params.stopLossMaxOut;
+    this.stopLossType = params.stopLossType;
+    this.stopLossTriggerPrice = params.stopLossTriggerPrice;
     this.takeProfitMinOut = params.takeProfitMinOut;
   }
 
@@ -104,22 +110,33 @@ export class SingleChainOrder {
   }
 
   private static async calculateAmountOutMin(input: CreateSingleChainOrderParams): Promise<bigint> {
-    const { amountOutMin, stopLossMaxOut } = input;
+    const { amountOutMin, stopLossType, stopLossTriggerPrice } = input;
 
     const scenario = this.getSingleChainOrderScenario({
       hasAmountOutMin: !!amountOutMin,
-      hasStopLoss: !!stopLossMaxOut,
+      hasStopLoss: !!stopLossType && !!stopLossTriggerPrice,
     });
 
     switch (scenario) {
       case 'QUOTE_REQUIRED': {
-        const quote = await QuoteProvider.getSingleChainQuote({
-          tokenIn: input.tokenIn,
-          amount: input.amountIn,
-          chainId: input.chainId,
-          tokenOut: input.tokenOut,
-        });
-        return (quote.amountOut * 93n) / 100n; // Add 7% reduced fixed amount to cover fees
+        const [quote, expenses] = await Promise.all([
+          QuoteProvider.getSingleChainQuote({
+            tokenIn: input.tokenIn,
+            amount: input.amountIn,
+            chainId: input.chainId,
+            tokenOut: input.tokenOut,
+          }),
+          estimateExpensesInTokenOut({
+            chainId: input.chainId,
+            tokenOut: input.tokenOut,
+            gasLimit: EVM_SINGLE_CHAIN_GAS_LIMIT,
+            getQuote: (p) => QuoteProvider.getSingleChainQuote(p),
+          }),
+        ]);
+
+        // Worst-case output already carries provider slippage; never use the nominal amountOut.
+        const swapOutput = quote.amountOutMin ?? quote.amountOut;
+        return estimateAmountOut(swapOutput, DEFAULT_COMMISSION_BPS, expenses, SINGLE_CHAIN_COMMISSION_DENOMINATOR);
       }
 
       case 'USE_PROVIDED_AMOUNT':

package/src/core/sdk.ts

@@ -4,6 +4,7 @@ import type { ApiResponse } from '../types/api.js';
 import type {
   CrossChainOrderPrepared,
   CrossChainUserIntentRequest,
+  DcaCrossChainUserIntentRequest,
   DcaSingleChainOrderPrepared,
   DcaSingleChainUserIntentRequest,
   SingleChainOrderPrepared,
@@ -32,6 +33,7 @@ export abstract class BaseSDK {
       body,
     });
 
+    console.debug(`url`, url, `body`, body)
     if (!response.ok) {
       const errorJson: ApiResponse = await response.json();
       const mainError = errorJson.error;
@@ -121,4 +123,13 @@ export abstract class BaseSDK {
   public static async validateDcaSingleChainOrder(intentRequest: DcaSingleChainUserIntentRequest): Promise<void> {
     return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/dca_order');
   }
+
+  public static async validateDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<void> {
+    return BaseSDK.validateOrder(intentRequest, '/validate_intent/cross_chain/dca_order');
+  }
+
+  public static async sendDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<ApiResponse> {
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+    return BaseSDK.makeRequest(`${AUCTIONEER_URL}/user_intent/cross_chain/dca_order`, body);
+  }
 }

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

@@ -86,13 +86,14 @@ export async function cancelSingleChainOrderInstructions(
   }
 
   const cancelLimitOrderIx = getCancelLimitOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,
     userTokenInAccount: userTokenInAccount.address,
     guardTokenInAccount: guardProgramAccount,
     tokenInProgram: tokenMintProgram.programAddress,
+    signer: createNoopSigner(orderUserAddress),
+    user: orderUserAddress
   });
 
   instructions.push(cancelLimitOrderIx);
@@ -245,7 +246,7 @@ export async function cancelCrossChainOrderInstructions(
 
   // Create the cancel order instruction
   const cancelOrderIx = getCancelOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
+    user: orderUserAddress,
     order: orderId,
     guard: guardAddress,
     recoveredTokenMint: recoverTokenMint,
@@ -256,6 +257,7 @@ export async function cancelCrossChainOrderInstructions(
     userCollateralTokenAccount: userCollateralTokenAccount,
     guardCollateralTokenAccount: guardCollateralTokenAccount,
     collateralTokenProgram: collateralTokenMintProgram.programAddress,
+    signer: createNoopSigner(orderUserAddress)
   });
 
   instructions.push(cancelOrderIx);

package/src/core/solana/client.ts

@@ -5,7 +5,7 @@ import {
   type RpcSubscriptions,
   type SolanaRpcApiMainnet,
   type SolanaRpcSubscriptionsApi,
-  sendAndConfirmTransactionFactory
+  sendAndConfirmTransactionFactory,
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
 

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

@@ -76,7 +76,8 @@ export async function cancelDcaSingleChainOrderInstructions(
   }
 
   const cancelLimitOrderIx = getCancelDcaOrderInstruction({
-    user: createNoopSigner(orderUserAddress),
+    user: orderUserAddress,
+    signer: createNoopSigner(orderUserAddress),
     order: orderId,
     guard: guardAddress,
     tokenInMint: chainOrder.data.tokenInMint,

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`,