@shogun-sdk/intents-sdk 1.0.0 → 1.0.2

package/src/core/sdk.ts

@@ -1,7 +1,9 @@
 import { chainIdToChainTypeMap } from '../chains.js';
 import { AUCTIONEER_URL } from '../constants.js';
 import { NetworkError } from '../errors/index.js';
+import type { ApiResponse } from '../types/api.js';
 import type { CreateOrderParams, PreparedOrder, UserIntentRequest } from '../types/intent.js';
+import { calculateAmounts } from '../utils/defillama.js';
 import { Parsers } from '../utils/parsers.js';
 import { Order } from './order.js';
 
@@ -21,6 +23,8 @@ export abstract class BaseSDK {
    */
   public abstract getUserAddress(): Promise<string>;
 
+  protected abstract cancelOrderInternal(orderId: string): Promise<string>;
+
   /**
    * Prepares an order for submission with chain-specific logic
    *
@@ -52,24 +56,52 @@ export abstract class BaseSDK {
   public async createOrder(params: CreateOrderParams): Promise<PreparedOrder> {
     const userAddress = await this.getUserAddress();
 
+    let minStablecoinAmount: bigint;
+    let destinationTokenMinAmount: bigint;
+
+    if (!params.minStablecoinAmount || !params.destinationTokenMinAmount) {
+      // Calculate missing values using DefiLlama
+      const { amountOut: calculatedAmountOut, minStablecoinsAmount: calculatedMinStablecoins } = await calculateAmounts(
+        {
+          srcChainId: params.sourceChainId,
+          tokenIn: params.sourceTokenAddress,
+          amountIn: params.sourceTokenAmount,
+          destChainId: params.destinationChainId,
+          tokenOut: params.destinationTokenAddress,
+        },
+      );
+
+      // Use provided values if available, otherwise use calculated ones
+      minStablecoinAmount = params.minStablecoinAmount ?? calculatedMinStablecoins;
+      destinationTokenMinAmount = params.destinationTokenMinAmount ?? calculatedAmountOut;
+    } else {
+      // Both values provided, use them directly
+      minStablecoinAmount = params.minStablecoinAmount;
+      destinationTokenMinAmount = params.destinationTokenMinAmount;
+    }
+
     // Order is validated upon creation
     const order = await Order.create({
       user: userAddress,
       sourceChainId: params.sourceChainId,
       sourceTokenAddress: params.sourceTokenAddress,
       sourceTokenAmount: params.sourceTokenAmount,
-      minStablecoinAmount: params.minStablecoinAmount,
+      minStablecoinAmount: minStablecoinAmount,
       deadline: params.deadline,
       destinationAddress: params.destinationAddress,
       destinationChainId: params.destinationChainId,
       destinationTokenAddress: params.destinationTokenAddress,
-      destinationTokenMinAmount: params.destinationTokenMinAmount,
+      destinationTokenMinAmount: destinationTokenMinAmount,
       extraTransfers: params.extraTransfers,
     });
 
     return this.prepareOrder(order);
   }
 
+  public async cancelOrder(orderId: string): Promise<string> {
+    return this.cancelOrderInternal(orderId);
+  }
+
   /**
    * Creates an order and sends it to the auctioneer in a single call
    *
@@ -81,9 +113,9 @@ export abstract class BaseSDK {
    * @throws {OrderCreationError} If order creation fails
    * @throws {NetworkError} If order submission fails
    */
-  public async createAndSendOrder(params: CreateOrderParams): Promise<Response> {
+  public async createAndSendOrder(params: CreateOrderParams): Promise<ApiResponse> {
     const preparedOrder = await this.createOrder(params);
-    return this.sendOrder(preparedOrder);
+    return BaseSDK.sendOrder(preparedOrder);
   }
 
   /**
@@ -98,7 +130,7 @@ export abstract class BaseSDK {
    * @returns User intent request object ready for submission to the auctioneer
    * @throws {BaseError} If conversion fails
    */
-  private getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
+  public static getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
     const sourceChain = preparedOrder.order.sourceChainId;
     const sourceChainType = chainIdToChainTypeMap[sourceChain];
     const executionDetails = preparedOrder.order.getExecutionDetails();
@@ -125,8 +157,8 @@ export abstract class BaseSDK {
    * @returns Promise resolving to the specific-chain tx hash
    * @throws {NetworkError} If the network request fails or returns an error
    */
-  public async sendOrder(preparedOrder: PreparedOrder): Promise<Response> {
-    const intentRequest = this.getUserIntentRequest(preparedOrder);
+  public static async sendOrder(preparedOrder: PreparedOrder): Promise<ApiResponse> {
+    const intentRequest = BaseSDK.getUserIntentRequest(preparedOrder);
     const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
 
     const url = `${AUCTIONEER_URL}/user_intent`;
@@ -139,7 +171,7 @@ export abstract class BaseSDK {
     });
 
     if (!response.ok) {
-      const errorJson = await response.json();
+      const errorJson: ApiResponse = await response.json();
 
       const extraErrorData = errorJson.extra_error_data;
       throw new NetworkError(`Server error`, {
@@ -149,6 +181,6 @@ export abstract class BaseSDK {
       });
     }
 
-    return response;
+    return response.json();
   }
 }

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

@@ -21,6 +21,9 @@ import { NATIVE_SOLANA_TOKEN_ADDRESS, SRC_CHAIN_GUARD, WRAPPED_SOL_MINT_ADDRESS
 import type { Order } from '../order.js';
 import { getDefaultSolanaRPC } from './client.js';
 import { getCreateOrderInstruction } from './generated/index.js';
+import type { ApiResponse } from '../../types/api.js';
+import type { PreparedOrder } from '../../types/intent.js';
+import { BaseSDK } from '../sdk.js';
 
 /**
  * Generates Solana order instructions for creating an order
@@ -129,3 +132,20 @@ export async function getSolanaOrderInstructions(order: Order): Promise<{
     orderKeyPair: orderSigner,
   };
 }
+
+export async function sendSolanaRequest({
+  order,
+  orderPubkey,
+}: {
+  order: Order;
+  orderPubkey: string;
+}): Promise<ApiResponse> {
+  const preparedOrder: PreparedOrder = {
+    order,
+    preparedData: {
+      orderPubkey,
+    },
+  };
+
+  return BaseSDK.sendOrder(preparedOrder);
+}

package/src/core/solana/sdk.ts

@@ -1,4 +1,5 @@
 import {
+  address,
   appendTransactionMessageInstructions,
   compileTransaction,
   createKeyPairFromBytes,
@@ -18,6 +19,7 @@ import { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { createSolanaClient, type SolanaClient } from './client.js';
 import { getSolanaOrderInstructions } from './order-instructions.js';
+import { fetchMaybeOrder } from './generated/index.js';
 
 /**
  * Solana-specific SDK implementation
@@ -57,6 +59,18 @@ export class SolanaSDK extends BaseSDK {
     return signer.address;
   }
 
+  protected override async cancelOrderInternal(orderId: string): Promise<string> {
+    const rpc = this.client.rpc;
+    const orderAddress = address(orderId);
+    const orderData = await fetchMaybeOrder(rpc, orderAddress);
+
+    if (!orderData) {
+      throw new Error('Order not found');
+    }
+
+    throw new Error('Method not implemented.');
+  }
+
   /**
    * Creates a CryptoKeyPair from the user's private key
    *

package/src/core/sui/order-transaction.ts

@@ -11,6 +11,9 @@ import {
 import { ValidationError } from '../../errors/index.js';
 import type { Order } from '../order.js';
 import { createSuiClient } from './client.js';
+import { BaseSDK } from '../sdk.js';
+import type { ApiResponse } from '../../types/api.js';
+import type { PreparedOrder } from '../../types/intent.js';
 
 /**
  * Generates Sui order transaction for creating an order
@@ -76,3 +79,20 @@ export async function getSuiOrderTransaction(order: Order): Promise<Transaction>
 
   return tx;
 }
+
+export async function sendSuiRequest({
+  order,
+  transactionDigest,
+}: {
+  order: Order;
+  transactionDigest: string;
+}): Promise<ApiResponse> {
+  const preparedOrder: PreparedOrder = {
+    order,
+    preparedData: {
+      transactionHash: transactionDigest,
+    },
+  };
+
+  return BaseSDK.sendOrder(preparedOrder);
+}

package/src/core/sui/sdk.ts

@@ -17,6 +17,10 @@ import { getSuiOrderTransaction } from './order-transaction.js';
  * Supports cross-chain swaps from Sui to other supported chains.
  */
 export class SuiSDK extends BaseSDK {
+  protected override cancelOrderInternal(): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
+
   /** Configuration for Sui connection and authentication */
   private readonly config: SuiConfig;
   /** Client for Sui RPC interactions and transaction handling */

package/src/errors/index.ts

@@ -83,6 +83,13 @@ export class InsufficientBalanceError extends BaseError {
   }
 }
 
+export class CalculateAmountError extends BaseError {
+  constructor(message: string, cause?: unknown) {
+    super(message, cause);
+    Object.setPrototypeOf(this, CalculateAmountError.prototype);
+  }
+}
+
 export class InsufficientAllowanceError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);

package/src/index.ts

@@ -1,5 +1,5 @@
-export type { ChainID, ChainType } from './chains.js';
-export { SupportedChains } from './chains.js';
+export { ChainID, ChainType, SupportedChains } from './chains.js';
+export type { SupportedEvmChain } from './chains.js';
 
 export type { EVMConfig, SolanaConfig, SuiConfig } from './config.js';
 export { EVMSDK } from './core/evm/sdk.js';
@@ -7,4 +7,15 @@ export { Order } from './core/order.js';
 export { SolanaSDK } from './core/solana/sdk.js';
 export { SuiSDK } from './core/sui/sdk.js';
 export { ValidationError } from './errors/index.js';
+export {
+  calculateAmounts,
+  chainIdToDefiLlamaChainMap,
+  createDefiLlamaCoinKey,
+  getCoinFromResponse,
+  getTokensData,
+} from './utils/defillama.js';
+export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
 export type { CreateOrderParams } from './types/intent.js';
+export { getEvmOrderTypedData, sendEvmRequest } from './core/evm/order-signature.js';
+export { getSolanaOrderInstructions, sendSolanaRequest } from './core/solana/order-instructions.js';
+export { getSuiOrderTransaction, sendSuiRequest } from './core/sui/order-transaction.js';

package/src/types/api.ts

@@ -0,0 +1,9 @@
+export type ApiResponse = {
+  success: boolean;
+  code: number;
+
+  data?: unknown;
+
+  error?: unknown;
+  extra_error_data?: unknown;
+};

package/src/types/intent.ts

@@ -18,12 +18,12 @@ export type CreateOrderParams = {
   /** Token address on the destination chain to receive */
   destinationTokenAddress: string;
   /** Minimum amount of destination tokens to receive, in smallest units */
-  destinationTokenMinAmount: bigint;
+  destinationTokenMinAmount?: bigint;
   /** Recipient wallet address on the destination chain */
   destinationAddress: string;
 
   /** Minimum amount of stablecoins in the intermediate swap, in smallest units */
-  minStablecoinAmount: bigint;
+  minStablecoinAmount?: bigint;
   /** Timestamp (in seconds) after which the order expires */
   deadline: number;
 

package/src/types/user-order.ts

@@ -0,0 +1,74 @@
+export enum OrderStatus {
+  // In auction stage, waiting for bids.
+  Auction = 'Auction',
+  // No bids were received for the order. Is set as limit order.
+  NoBids = 'NoBids',
+  // The order got a winner bid and the solver is going to execute it.
+  Executing = 'Executing',
+  // The order was correctly executed.
+  Fulfilled = 'Fulfilled',
+  // The order was cancelled before execution.
+  Cancelled = 'Cancelled',
+  // The order was not fulfilled before its deadline.
+  Outdated = 'Outdated',
+}
+
+export type UserOrder = {
+  // Order ID index
+  orderId: string;
+  // Order status
+  orderStatus: OrderStatus;
+
+  // User address initiating the intent
+  user: string;
+  // Destination address for the operation (e.g., recipient address)
+  destinationAddress: string;
+
+  // Source chain identifier (e.g., Ethereum, Solana)
+  srcChainId: number;
+  // Destination chain identifier
+  destChainId: number;
+
+  // The token being spent in the operation (e.g., "ETH", "BTC")
+  tokenIn: string;
+  // Token to be received after the operation (e.g., "USDT", "DAI")
+  tokenOut: string;
+
+  // The amount of the input token to be used in the operation
+  amountIn: string;
+  // The minimum amount of the output token to be received after the operation
+  amountOutMin: string;
+  // Minimum amount of stablecoins that Tokens IN may be swapped for
+  minStablecoinsAmount: string;
+  // Amount if stablecoins, that tokens IN were swapped into
+  lockedStablecoins: string;
+
+  // `true` - tokens IN were swapped into stablecoins
+  tokensInWereSwappedToStablecoins: false;
+
+  // `execution_details` JSON String
+  executionDetails: string;
+  // SHA-256 hash of `execution_details` JSON String (hex format)
+  executionDetailsHash: string;
+
+  // Deadline for the operation, in Unix timestamp format, in seconds
+  deadline: number;
+  // Order creation time, in Unix timestamp format, in seconds
+  orderCreationTime: number;
+
+  // Requested array of extra transfers with fixed amounts
+  extraTransfers?: {
+    amount: string;
+    receiver: string;
+    token: string;
+  }[];
+
+  // Permit2 nonce, user for EVM order
+  nonce?: string;
+  // Order fulfillment timestamp, in seconds
+  orderFulfillmentTimestamp?: number;
+  // Transaction hash of order execution
+  transactionHash?: string;
+  // The output amount
+  amountOut?: string;
+};

package/src/utils/defillama.ts

@@ -0,0 +1,179 @@
+import { ChainID, type SupportedChain } from '../chains.js';
+import {
+  isNativeTokenEvmAddress,
+  NATIVE_SOLANA_TOKEN_ADDRESS,
+  REDUCTION_FACTOR,
+  STABLECOIN_DECIMALS,
+  WRAPPED_SOL_MINT_ADDRESS,
+} from '../constants.js';
+import { CalculateAmountError } from '../errors/index.js';
+import { Parsers } from './parsers.js';
+
+const TOKEN_PRICE_BASE_URL: string = 'https://coins.llama.fi/prices/current/';
+
+/**
+ * Response structure from DefiLlama API for token prices
+ */
+export interface DefiLlamaTokensResponse {
+  coins: Record<string, DefiLlamaCoinData>;
+}
+
+/**
+ * Individual token data from DefiLlama API
+ */
+export interface DefiLlamaCoinData {
+  /** Number of decimal places for the token */
+  decimals: number;
+  /** Token symbol (e.g., "ETH", "USDC") */
+  symbol: string;
+  /** Current price in USD */
+  price: number;
+  /** Unix timestamp of the price data */
+  timestamp: number;
+  /** Confidence level of the price data (0-1) */
+  confidence: number;
+}
+
+/**
+ * Maps chain IDs to their corresponding chain types
+ * Used to determine which SDK implementation to use for a given chain
+ */
+export const chainIdToDefiLlamaChainMap = {
+  [ChainID.Arbitrum]: 'arbitrum',
+  [ChainID.Base]: 'base',
+  [ChainID.Optimism]: 'optimism',
+  [ChainID.Solana]: 'solana',
+  [ChainID.Sui]: 'sui',
+} as const;
+
+/**
+ * Creates DefiLlama coin key from chain ID and token address
+ * Format: "chainName:tokenAddress"
+ */
+export const createDefiLlamaCoinKey = (chainId: ChainID, tokenAddress: string): string => {
+  const chainName = chainIdToDefiLlamaChainMap[chainId];
+  if (!chainName) {
+    throw new CalculateAmountError(`Unsupported chain ID for DefiLlama: ${chainId}`);
+  }
+
+  return `${chainName}:${toDefiLlamaToken(tokenAddress)}`;
+};
+
+/**
+ * Retrieves token data from DefiLlama response by chain and address
+ */
+export const getCoinFromResponse = (
+  response: DefiLlamaTokensResponse,
+  chainId: ChainID,
+  tokenAddress: string,
+): DefiLlamaCoinData => {
+  const key = createDefiLlamaCoinKey(chainId, tokenAddress);
+  const coin = response.coins[key];
+
+  if (!coin) {
+    throw new CalculateAmountError(`DefiLlama coin not found for ${key}`);
+  }
+
+  return coin;
+};
+
+/**
+ * Converts Solana native token address to wrapped SOL mint address
+ * DefiLlama uses wrapped SOL mint address for native SOL
+ *
+ * @param tokenAddress The token address to convert
+ * @returns The DefiLlama-compatible token address
+ */
+function toDefiLlamaToken(tokenAddress: string): string {
+  if (isNativeTokenEvmAddress(tokenAddress)) {
+    return '0x0000000000000000000000000000000000000000';
+  }
+
+  if (tokenAddress === NATIVE_SOLANA_TOKEN_ADDRESS) {
+    return WRAPPED_SOL_MINT_ADDRESS;
+  }
+
+  return tokenAddress;
+}
+
+/**
+ * Builds a comma-separated query string for DefiLlama API token requests
+ *
+ * Converts an array of chain/token pairs into the format expected by DefiLlama's
+ * bulk price endpoint: "chain1:token1,chain2:token2,..."
+ *
+ * @param tokens - Array of [ChainID, token address] tuples to query
+ * @returns Comma-separated string of DefiLlama coin keys
+ *
+ * @throws {CalculateAmountError} When any chain ID is not supported by DefiLlama
+ */
+function buildTokensQueryString(tokens: Array<[ChainID, string]>): string {
+  return tokens.map(([chainId, tokenAddress]) => createDefiLlamaCoinKey(chainId, tokenAddress)).join(',');
+}
+
+/**
+ * Fetch tokens data for array of coins
+ *
+ * @param tokens Array of [ChainID, Token Address] tuples
+ * @returns Promise resolving to DefiLlama tokens response
+ * @throws {CalculateAmountError} If the request fails or response is invalid
+ */
+export async function getTokensData(tokens: Array<[ChainID, string]>): Promise<DefiLlamaTokensResponse> {
+  const tokensStr = buildTokensQueryString(tokens);
+
+  const url = `${TOKEN_PRICE_BASE_URL}${tokensStr}`;
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new CalculateAmountError(`Failed to fetch token prices: ${response.status} ${response.statusText}`);
+  }
+
+  const data: DefiLlamaTokensResponse = await response.json();
+  return data;
+}
+export async function calculateAmounts({
+  srcChainId,
+  tokenIn,
+  amountIn,
+  destChainId,
+  tokenOut,
+}: {
+  srcChainId: SupportedChain;
+  tokenIn: string;
+  amountIn: bigint;
+  destChainId: SupportedChain;
+  tokenOut: string;
+}): Promise<{ amountOut: bigint; minStablecoinsAmount: bigint }> {
+  // Fetch token data from DefiLlama
+  const tokensResponse = await getTokensData([
+    [srcChainId, tokenIn],
+    [destChainId, tokenOut],
+  ]);
+
+  // Get token data for input token
+  const tokenInData = getCoinFromResponse(tokensResponse, srcChainId, tokenIn);
+  if (!tokenInData) {
+    throw new CalculateAmountError(`Token ${tokenIn} for chain ${srcChainId} not found in DefiLlama response`);
+  }
+
+  // Get token data for output token
+  const tokenOutData = getCoinFromResponse(tokensResponse, destChainId, tokenOut);
+  if (!tokenOutData) {
+    throw new CalculateAmountError(`Token ${tokenOut} for chain ${destChainId} not found in DefiLlama response`);
+  }
+
+  // Calculate 80% of the amount_in value as amount_out_min and min_stablecoins_amount
+  const tokenInUsdAmount = Parsers.bigintToFloat(amountIn, tokenInData.decimals) * tokenInData.price;
+  const amountInUsdReduced = tokenInUsdAmount * REDUCTION_FACTOR;
+  const amountOutReduced = amountInUsdReduced / tokenOutData.price;
+
+  const amountOut = Parsers.floatToBigint(amountOutReduced, tokenOutData.decimals);
+  const minStablecoinsAmount = Parsers.floatToBigint(amountInUsdReduced, STABLECOIN_DECIMALS);
+
+  return { amountOut, minStablecoinsAmount };
+}

package/src/utils/order-validator.ts

@@ -92,7 +92,7 @@ export class OrderValidator {
 
     await sourceValidator.validateSourceChain(order);
 
-    this.commonValidator.validateCrossChain(order.sourceChainId, order.destinationChainId);
+    // this.commonValidator.validateCrossChain(order.sourceChainId, order.destinationChainId);
 
     const destinationValidator = ValidatorFactory.getValidatorForChain(order.destinationChainId);
 

package/src/utils/parsers.ts

@@ -1,8 +1,55 @@
 /* eslint-disable @typescript-eslint/no-namespace */
+import { formatUnits, parseUnits } from 'viem';
+import { CalculateAmountError } from '../errors/index.js';
 
 export namespace Parsers {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export function bigIntReplacer(_key: string, value: any): any {
     return typeof value === 'bigint' ? value.toString() : value;
   }
+
+  /**
+   * Converts a bigint amount to a floating point USD value
+   * @param amount Amount in token's smallest unit
+   * @param decimals Number of decimal places for the token
+   * @returns USD value as number
+   */
+  export function bigintToFloat(amount: bigint, decimals: number): number {
+    const formatted = formatUnits(amount, decimals);
+    const result = parseFloat(formatted);
+
+    if (!Number.isFinite(result)) {
+      throw new CalculateAmountError(`Conversion resulted in invalid number: ${formatted}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Converts a floating point USD value to bigint amount
+   * Uses viem's parseUnits for consistency and reliability
+   * @param usdValue USD value as number
+   * @param decimals Number of decimal places for the token
+   * @returns Amount in token's smallest unit
+   */
+  export function floatToBigint(usdValue: number, decimals: number): bigint {
+    if (!Number.isFinite(usdValue) || usdValue < 0) {
+      throw new CalculateAmountError(`Invalid USD value: ${usdValue}`);
+    }
+
+    if (decimals < 0 || decimals > 77) {
+      throw new CalculateAmountError(`Invalid decimals: ${decimals}`);
+    }
+
+    // Convert to fixed-precision string to avoid floating point issues
+    const valueString = usdValue.toFixed(decimals);
+
+    try {
+      return parseUnits(valueString, decimals);
+    } catch (error) {
+      throw new CalculateAmountError(
+        `Failed to convert ${usdValue} to bigint with ${decimals} decimals: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
 }

package/dist/_esm/chains.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chains.js","sourceRoot":"","sources":["../../src/chains.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,CAAN,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,8BAAiB,CAAA;IACjB,wBAAW,CAAA;AACb,CAAC,EAJW,SAAS,KAAT,SAAS,QAIpB;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,OAMX;AAND,WAAY,OAAO;IACjB,iDAAgB,CAAA;IAChB,8CAAa,CAAA;IACb,wCAAW,CAAA;IACX,+CAAgB,CAAA;IAChB,qCAAS,CAAA;AACX,CAAC,EANW,OAAO,KAAP,OAAO,QAMlB;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAU,CAAC;AA8BxH;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA2B,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAe,CAAC,CAAC;AAEvH;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG;IACjC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,GAAG;IAC7B,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,GAAG;IACjC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM;IAClC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,GAAG;CACpB,CAAC"}

package/dist/_esm/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAGrE,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,4CAAuD;IAC3E,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,4CAAuD;IAC3E,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,4CAAuD;CACxE,CAAC;AAEF,gFAAgF;AAChF,iFAAiF;AACjF,iFAAiF;AACjF,6EAA6E;AAC7E,+EAA+E;AAC/E,mBAAmB;AACnB,4EAA4E;AAC5E,IAAI;AAEJ,MAAM,CAAC,MAAM,eAAe,GAAgD;IAC1E,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,4CAAuD;IAC3E,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,4CAAuD;IAC3E,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,4CAAuD;IACvE,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,8CAA8C,CAAC;IACzE,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,oEAAoE;CACpF,CAAC;AAEF,mFAAmF;AACnF,MAAM;AACN,mFAAmF;AACnF,mFAAmF;AACnF,+EAA+E;AAC/E,iFAAiF;AACjF,qBAAqB;AACrB,8EAA8E;AAC9E,MAAM;AAEN,MAAM,CAAC,MAAM,2BAA2B,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAElG,MAAM,CAAC,MAAM,wBAAwB,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAE/F,MAAM,CAAC,MAAM,cAAc,GAAG,oEAAoE,CAAC;AAEnG,0GAA0G;AAE1G,MAAM,CAAC,MAAM,yBAAyB,GACpC,gFAAgF,CAAC;AAEnF,MAAM,CAAC,MAAM,yBAAyB,GACpC,gFAAgF,CAAC;AAEnF;;GAEG;AACH,sFAAsF;AACtF,MAAM,CAAC,MAAM,cAAc,GAAG,uBAAuB,CAAC;AAEtD,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,CAAC;AAC1C,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,CAAC;AAC5C,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,CAAC"}