@shogun-sdk/intents-sdk 1.1.1 → 1.2.0

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

@@ -0,0 +1,142 @@
+import {
+  address,
+  addSignersToTransactionMessage,
+  appendTransactionMessageInstructions,
+  createNoopSigner,
+  createSolanaRpc,
+  createTransactionMessage,
+  fetchEncodedAccount,
+  generateKeyPairSigner,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  getTransactionCodec,
+  partiallySignTransactionMessageWithSigners,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Address,
+  type IInstruction,
+} from '@solana/kit';
+import type { DcaSingleChainOrder } from '../../orders/dca-single-chain.js';
+import type { SolanaOrderInstructionResult } from '../order-instructions.js';
+import { getDefaultSolanaRPC } from '../client.js';
+import { genSecretHashAndNumber } from '../utils.js';
+import {
+  NATIVE_SOLANA_TOKEN_ADDRESS,
+  SINGLE_CHAIN_GUARD_ADDRESSES,
+  WRAPPED_SOL_MINT_ADDRESS,
+} from '../../../constants.js';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  fetchMint,
+  getCreateAssociatedTokenInstructionAsync,
+  getSyncNativeInstruction,
+} from '@solana-program/token';
+import { ChainID } from '../../../chains.js';
+import { getTransferSolInstruction } from '@solana-program/system';
+import { getCreateDcaOrderInstructionAsync } from '../generated/single-chain/index.js';
+
+export async function getSolanaDcaSingleChainOrderInstructions(
+  order: DcaSingleChainOrder,
+  options?: { rpcUrl?: string },
+): Promise<SolanaOrderInstructionResult & { secretNumber: string }> {
+  const rpc = options?.rpcUrl ? createSolanaRpc(options.rpcUrl) : getDefaultSolanaRPC();
+  const orderSigner = await generateKeyPairSigner();
+  const signer = createNoopSigner(order.user as Address);
+
+  let tokenInMint = address(order.tokenIn);
+
+  const { secretHash, secretNumber } = genSecretHashAndNumber(order);
+
+  const orderUserAddress = address(order.user);
+  const spendingNative = tokenInMint === NATIVE_SOLANA_TOKEN_ADDRESS;
+
+  if (spendingNative) {
+    tokenInMint = WRAPPED_SOL_MINT_ADDRESS;
+  }
+
+  const tokenMintProgram = await fetchMint(rpc, tokenInMint);
+
+  const guardAddress = address(SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana]); // Assuming DCA uses same guard
+  const addressEncoder = getAddressEncoder();
+  const instructions: Array<IInstruction> = [];
+
+  const [tokenInProgramAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(orderUserAddress),
+      addressEncoder.encode(tokenMintProgram.programAddress),
+      addressEncoder.encode(tokenInMint),
+    ],
+  });
+
+  const userTokenInAccount = await fetchEncodedAccount(rpc, tokenInProgramAccount);
+
+  if (!userTokenInAccount.exists) {
+    const createAccountIx = await getCreateAssociatedTokenInstructionAsync({
+      payer: signer,
+      ata: tokenInProgramAccount,
+      owner: orderUserAddress,
+      mint: tokenMintProgram.address,
+      tokenProgram: tokenMintProgram.programAddress,
+    });
+
+    instructions.push(createAccountIx);
+  }
+
+  const totalAmountIn = BigInt(order.amountInPerInterval) * BigInt(order.totalIntervals);
+
+  if (spendingNative) {
+    const transferIx = getTransferSolInstruction({
+      amount: totalAmountIn,
+      destination: userTokenInAccount.address,
+      source: signer,
+    });
+
+    instructions.push(transferIx);
+
+    const syncNativeIx = getSyncNativeInstruction({
+      account: userTokenInAccount.address,
+    });
+
+    instructions.push(syncNativeIx);
+  }
+
+  const createDcaOrderIx = await getCreateDcaOrderInstructionAsync({
+    user: signer,
+    order: orderSigner,
+    guard: guardAddress,
+    tokenInMint: tokenInMint,
+    userTokenInAccount: userTokenInAccount.address,
+    tokenInProgram: tokenMintProgram.programAddress,
+    amountInPerInterval: order.amountInPerInterval,
+    totalIntervals: order.totalIntervals,
+    intervalDuration: order.intervalDuration,
+    deadline: order.deadline,
+    amountOutMin: order.amountOutMin,
+    secretHash: Uint8Array.from(secretHash),
+    extraTransfersAmounts: [], // TODO: Implement extra transfers
+  });
+
+  instructions.push(createDcaOrderIx);
+
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();
+
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx),
+    (tx) => addSignersToTransactionMessage([orderSigner], tx),
+  );
+
+  const partiallySignedTransaction = await partiallySignTransactionMessageWithSigners(txMessage);
+
+  const txBytes = getTransactionCodec().encode(partiallySignedTransaction);
+
+  return {
+    orderAddress: orderSigner.address,
+    txBytes,
+    secretNumber,
+  };
+}

package/src/core/solana/inspect.ts

@@ -0,0 +1,50 @@
+import { address, createSolanaRpc, type Base58EncodedBytes } from '@solana/kit';
+import { getDefaultSolanaRPC } from './client.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Inspect Solana guards to find orders that are currently locked on-chain.
+ * @param userAddress - The user's Solana address
+ * @param config - The Solana RPC configuration
+ * @returns An object containing the Solana guard programs for cross-chain and single-chain orders
+ */
+export async function getSolanaOrdersWithLockedFunds(userAddress: string, config?: { rpcUrl?: string }) {
+  const rpc = config?.rpcUrl ? createSolanaRpc(config.rpcUrl) : getDefaultSolanaRPC();
+
+  // const singleChainGuardAddress = SINGLE_CHAIN_GUARD_ADDRESSES[ChainID.Solana];
+
+  const programAccountAddress = address('43cctGU9QJ4WEPzLoNEvo3TPiv6nMUG9puN2pXQSnB6V');
+  const programAccountsConfig = {
+    encoding: 'base64',
+    filters: [
+      {
+        memcmp: {
+          offset: 8n,
+          encoding: 'base58',
+          bytes: userAddress as Base58EncodedBytes,
+        },
+      },
+    ],
+  } as Readonly<unknown>;
+
+  logger.info(`Fetching cross-chain guard programs for user: ${userAddress}`);
+  const crossChainGuardPrograms = await rpc.getProgramAccounts(programAccountAddress, programAccountsConfig).send();
+  logger.info(`Found ${crossChainGuardPrograms.length} cross-chain guard programs`);
+  // const singleChainGuardPrograms = await rpc.getProgramAccounts(address(singleChainGuardAddress), programAccountsConfig).send();
+
+  // const crossChainCodec = getOrderCodec();
+  // const singleChainCodec = getLimitOrderCodec();
+  // const base64Encoder = getBase64Encoder();
+
+  const crossChainGuardProgramsWithOrders = crossChainGuardPrograms.map(({ pubkey, account }) => {
+    logger.info(`Account data: ${account} and pubkey: ${pubkey}`);
+
+    return {
+      pubkey,
+    };
+  });
+
+  return {
+    crossChainGuardPrograms: crossChainGuardProgramsWithOrders,
+  };
+}

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

@@ -262,4 +262,4 @@ export async function getSolanaCrossChainOrderInstructions(
     orderAddress: orderSigner.address,
     txBytes: Uint8Array.from(txBytes),
   };
-}
+}

package/src/core/solana/sdk.ts

@@ -22,12 +22,19 @@ import { BaseSDK } from '../sdk.js';
 import { createSolanaClient, type SolanaClient } from './client.js';
 import { cancelCrossChainOrderInstructions, cancelSingleChainOrderInstructions } from './cancel-order.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type {
+  CrossChainOrderPrepared,
+  DcaSingleChainOrderPrepared,
+  SingleChainOrderPrepared,
+} from '../../types/intent.js';
 import { getSolanaCrossChainOrderInstructions, getSolanaSingleChainOrderInstructions } from './order-instructions.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
 import { ChainID } from '../../chains.js';
 import { bytesToHex } from 'viem';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
+import { getSolanaDcaSingleChainOrderInstructions } from './dca/create-order.js';
+import { cancelDcaSingleChainOrderInstructions } from './dca/cancel-order.js';
 
 /**
  * Solana-specific SDK implementation
@@ -224,7 +231,7 @@ export class SolanaSDK extends BaseSDK {
     };
   }
 
-  protected async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+  protected override async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
     const signerKeyPair = await this.getUserCryptoKeypair();
 
     const { orderAddress, txBytes, secretNumber } = await getSolanaSingleChainOrderInstructions(order);
@@ -237,6 +244,62 @@ export class SolanaSDK extends BaseSDK {
 
     const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
 
+    await this.client.rpc
+      .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
+      .send();
+
+    return {
+      order,
+      preparedData: {
+        orderPubkey: orderAddress,
+        secretNumber,
+      },
+    };
+  }
+  public async cancelDcaSingleChainOrder(orderId: string): Promise<string> {
+    const instructions = await cancelDcaSingleChainOrderInstructions(orderId, { rpcUrl: this.config.rpcProviderUrl });
+    const signer = await this.getUserSigner();
+    const signerKeyPair = await this.getUserCryptoKeypair();
+
+    const noopSigner = createNoopSigner(signer.address);
+
+    const { value: latestBlockhash } = await this.client.rpc
+      .getLatestBlockhash({ commitment: this.config.commitment })
+      .send();
+
+    const transactionMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (tx) => setTransactionMessageFeePayerSigner(noopSigner, tx),
+      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+      (tx) => appendTransactionMessageInstructions(instructions, tx),
+    );
+
+    const myTx = compileTransaction(transactionMessage);
+
+    const signature = await signTransaction([signerKeyPair], myTx);
+
+    await this.client.sendAndConfirmTransaction(signature, {
+      commitment: this.config.commitment,
+    });
+
+    return orderId;
+  }
+
+  protected override async prepareDcaSingleChainOrder(
+    order: DcaSingleChainOrder,
+  ): Promise<DcaSingleChainOrderPrepared> {
+    const signerKeyPair = await this.getUserCryptoKeypair();
+
+    const { orderAddress, txBytes, secretNumber } = await getSolanaDcaSingleChainOrderInstructions(order);
+
+    const transactionCodec = getTransactionCodec();
+
+    const tx = transactionCodec.decode(txBytes);
+
+    const signedTx = await partiallySignTransaction([signerKeyPair], tx);
+
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTx);
+
     await this.client.rpc
       .sendTransaction(encodedTransaction, { preflightCommitment: this.config.commitment, encoding: 'base64' })
       .send();

package/src/core/solana/utils.ts

@@ -2,8 +2,9 @@ import BN from 'bn.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import { PublicKey } from '@solana/web3.js';
 import sha3 from 'js-sha3';
+import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 
-export function genSecretHashAndNumber(order: SingleChainOrder): {
+export function genSecretHashAndNumber(order: SingleChainOrder | DcaSingleChainOrder): {
   secretHash: number[];
   secretNumber: string;
 } {

package/src/core/solana/validator.ts

@@ -27,4 +27,8 @@ export class SolanaValidator extends BaseValidator {
     // No chain-specific validation implemented for now for Solana
     return;
   }
+
+  override async validateDcaSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/core/sui/sdk.ts

@@ -5,7 +5,7 @@ import { BaseSDK } from '../sdk.js';
 import { createSuiClient } from './client.js';
 import { getSuiOrderTransaction } from './order-transaction.js';
 import { getSuiCancelCrossChainOrder } from './cancel.js';
-import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { CrossChainOrderPrepared } from '../../types/intent.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
 import { ChainID } from '../../chains.js';
@@ -57,10 +57,6 @@ export class SuiSDK extends BaseSDK {
     return Ed25519Keypair.fromSecretKey(this.config.privateKey);
   }
 
-  protected override prepareSingleChainOrder(): Promise<SingleChainOrderPrepared> {
-    throw new Error('Single-chain orders are not supported on Sui');
-  }
-
   public async authenticate(token?: string): Promise<string> {
     const wallet = await this.getUserAddress();
 
@@ -103,7 +99,7 @@ export class SuiSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Sui-specific data
    * @protected
    */
-  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+  protected override async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
     const signer = this.getKeyPair();
 
     const transaction = await getSuiOrderTransaction(order);

package/src/core/sui/validator.ts

@@ -1,6 +1,7 @@
 import { isValidSuiAddress, normalizeSuiAddress } from '@mysten/sui/utils';
 import { MAX_UINT_64 } from '../../constants.js';
 import { BaseValidator } from '../../utils/base-validator.js';
+import { ValidationError } from '../../errors/index.js';
 
 const SUI_TOKEN_ADDRESS_REGEX = /^0x[a-fA-F0-9]{64}::\w+::\w+$/;
 
@@ -33,4 +34,8 @@ export class SuiValidator extends BaseValidator {
   override validateSingleChainOrderFeasability(): Promise<void> {
     return Promise.resolve();
   }
+
+  override validateDcaSingleChainOrderFeasability(): Promise<void> {
+    throw new ValidationError('DCA orders are not supported on Sui');
+  }
 }

package/src/index.ts

@@ -14,7 +14,15 @@ export { fetchUserOrders } from './core/orders/api/fetch.js';
 export { AuctioneerAPI } from './core/orders/api/index.js';
 export { type FetchJWTParams, type FetchSiweMessageParams, fetchJWTToken, fetchSiweMessage } from './auth/siwe.js';
 export { ValidationError } from './errors/index.js';
-export { type ApiCrossChainOrder, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, type ChainOrderStatus, isErrorApiResponse, isSuccessApiResponse } from './types/api.js';
+export {
+  type ApiCrossChainOrder,
+  type ApiResponse,
+  type ApiSingleChainOrder,
+  type ApiUserOrders,
+  type ChainOrderStatus,
+  isErrorApiResponse,
+  isSuccessApiResponse,
+} from './types/api.js';
 export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
 export {
@@ -24,8 +32,11 @@ export {
   type CancelCrossChainOrderParams,
   getInvalidateNoncesRawData,
 } from './core/evm/cancel-order.js';
+export { cancelDcaSingleChainOrderInstructions } from './core/solana/dca/cancel-order.js';
 export { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './core/evm/order-signature.js';
 
+export { getSolanaOrdersWithLockedFunds } from './core/solana/inspect.js';
+
 export {
   getSolanaCrossChainOrderInstructions,
   getSolanaSingleChainOrderInstructions,

package/src/types/api.ts

@@ -75,4 +75,4 @@ export function isErrorApiResponse<T extends ValidResponseData>(
   response: ApiResponse<T>,
 ): response is ApiResponse<T> & { success: false; error: unknown } {
   return !response.success;
-}
+}

package/src/types/intent.ts

@@ -2,6 +2,7 @@ import type { SupportedChain } from '../chains.js';
 import type { CrossChainOrder } from '../core/orders/cross-chain.js';
 import type { ExtraTransfer } from '../core/orders/common.js';
 import type { SingleChainOrder } from '../core/orders/single-chain.js';
+import type { DcaSingleChainOrder } from '../core/orders/dca-single-chain.js';
 
 /**
  * Details required to execute the order on the destination chain
@@ -120,3 +121,29 @@ export type SingleChainOrderPrepared = {
   order: SingleChainOrder;
   preparedData: SingleChainPreparedData;
 };
+
+export type DcaSingleChainUserIntentRequest = {
+  genericData: DcaSingleChainOrder;
+  chainSpecificData: {
+    EVM?: DcaSingleChainEVMPreparedData;
+    Solana?: DcaSingleChainSolanaPreparedData;
+    Sui?: never; // DCA not supported on Sui
+  };
+};
+
+export type DcaSingleChainEVMPreparedData = {
+  nonce: string;
+  signature: string | Hash;
+};
+
+export type DcaSingleChainSolanaPreparedData = {
+  secretNumber: string;
+  orderPubkey: string;
+};
+
+export type DcaSingleChainPreparedData = DcaSingleChainEVMPreparedData | DcaSingleChainSolanaPreparedData;
+
+export type DcaSingleChainOrderPrepared = {
+  order: DcaSingleChainOrder;
+  preparedData: DcaSingleChainPreparedData;
+};

package/src/utils/base-validator.ts

@@ -1,4 +1,5 @@
 import type { CreateCrossChainOrderParams } from '../core/orders/cross-chain.js';
+import type { CreateDcaSingleChainOrderParams } from '../core/orders/dca-single-chain.js';
 import type { CreateSingleChainOrderParams } from '../core/orders/single-chain.js';
 import { ValidationError } from '../errors/index.js';
 import type { IChainValidator } from './order-validator.js';
@@ -59,6 +60,45 @@ export abstract class BaseValidator implements IChainValidator {
     }
   }
 
+  abstract validateDcaSingleChainOrderFeasability(
+    order: CreateDcaSingleChainOrderParams & { user: string },
+  ): Promise<void>;
+
+  async validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void> {
+    this.validateTokenAddress(order.tokenIn);
+    this.validateTokenAddress(order.tokenOut);
+    this.validateAmount(order.amountInPerInterval);
+    this.validateAmount(order.amountOutMin ?? 1n);
+    this.validateAddress(order.destinationAddress);
+
+    // Validate DCA-specific parameters
+    if (order.totalIntervals <= 0) {
+      throw new ValidationError('Total intervals must be greater than 0');
+    }
+
+    if (order.intervalDuration <= 0) {
+      throw new ValidationError('Interval duration must be greater than 0');
+    }
+
+    if (order.startTime < 0) {
+      throw new ValidationError('Start time must be non-negative');
+    }
+
+    // Validate total amount doesn't overflow
+    const totalAmount = order.amountInPerInterval * BigInt(order.totalIntervals);
+    this.validateAmount(totalAmount);
+
+    if (order.extraTransfers) {
+      for (const extraTransfer of order.extraTransfers) {
+        this.validateAddress(extraTransfer.receiver);
+        this.validateTokenAddress(extraTransfer.token);
+        this.validateAmount(extraTransfer.amount);
+      }
+    }
+
+    await this.validateDcaSingleChainOrderFeasability(order);
+  }
+
   /**
    * Helper methods that throw specific validation errors
    */

package/src/utils/order-validator.ts

@@ -26,6 +26,7 @@ export interface IChainValidator extends IAddressValidator, ITokenValidator, IAm
   validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
   validateDestinationChain(order: CreateCrossChainOrderParams): void;
   validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
+  validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void>;
 }
 
 /**
@@ -99,3 +100,40 @@ export class SingleChainOrderValidator {
     chainValidator.validateSingleChainOrder(order);
   }
 }
+
+import type { CreateDcaSingleChainOrderParams } from '../core/orders/dca-single-chain.js';
+
+export interface IDcaValidator {
+  validateDcaSingleChainOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void>;
+}
+
+export class DcaSingleChainOrderValidator {
+  private readonly commonValidator = new CommonValidator();
+
+  async validateOrder(order: CreateDcaSingleChainOrderParams & { user: string }): Promise<void> {
+    this.commonValidator.validateDeadline(order.deadline);
+
+    // Validate start time is in the future or current time
+    if (order.startTime < Math.floor(Date.now() / 1000)) {
+      throw new ValidationError('Start time must be in the future or current time');
+    }
+
+    // Validate intervals
+    if (order.totalIntervals <= 0) {
+      throw new ValidationError('Total intervals must be greater than 0');
+    }
+
+    if (order.intervalDuration <= 0) {
+      throw new ValidationError('Interval duration must be greater than 0');
+    }
+
+    // Validate that the order will complete before deadline
+    const estimatedCompletionTime = order.startTime + order.totalIntervals * order.intervalDuration;
+    if (estimatedCompletionTime > order.deadline) {
+      throw new ValidationError('Order would complete after deadline');
+    }
+
+    const chainValidator = ValidatorFactory.getValidatorForChain(order.chainId);
+    await chainValidator.validateDcaSingleChainOrder(order);
+  }
+}

package/src/utils/quote/liquidswap.ts

@@ -18,8 +18,8 @@ const LIQUID_SWAP_API_URL = 'https://api.liqd.ag';
 
 export class LiquidSwapQuoteProvider {
   public async getQuote(liquidSwapParams: LiquidSwapQuoteParams): Promise<LiquidSwapQuoteResponse> {
-    const params = {...liquidSwapParams};
-    
+    const params = { ...liquidSwapParams };
+
     if (isNativeEvmToken(params.tokenOut)) {
       params.tokenOut = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
     }