@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

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

@@ -0,0 +1,163 @@
+import { encodeFunctionData, type Hex } from 'viem';
+import type { ExtraTransfer } from '../orders/common.js';
+
+export type CancelSingleChainOrderParams = {
+  orderId: string;
+  user: string;
+  tokenIn: string;
+  amountIn: bigint;
+  requestedOutput: ExtraTransfer;
+  extraTransfers: ExtraTransfer[];
+  encodedExternalCallData: string;
+  deadline: number;
+  nonce: bigint;
+};
+
+export type CancelCrossChainOrderParams = {
+  orderId: string;
+  user: string;
+  tokenIn: string;
+  amountIn: bigint;
+  srcChainId: number;
+  deadline: number;
+  minStablecoinsAmount: bigint;
+  executionDetailsHash: string;
+  nonce: bigint;
+};
+
+const CROSS_CHAIN_CANCEL_ORDER_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: 'user', type: 'address' },
+          { name: 'tokenIn', type: 'address' },
+          { name: 'srcChainId', type: 'uint256' },
+          { name: 'deadline', type: 'uint256' },
+          { name: 'amountIn', type: 'uint256' },
+          { name: 'minStablecoinsAmount', type: 'uint256' },
+          { name: 'executionDetailsHash', type: 'bytes32' },
+          { name: 'nonce', type: 'uint256' },
+        ],
+        name: 'orderInfo',
+        type: 'tuple',
+      },
+    ],
+    name: 'cancelOrder',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+const SINGLE_CHAIN_CANCEL_ORDER_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          { name: 'amountIn', type: 'uint256' },
+          { name: 'tokenIn', type: 'address' },
+          { name: 'deadline', type: 'uint256' },
+          { name: 'nonce', type: 'uint256' },
+          { name: 'encodedExternalCallData', type: 'bytes' },
+          {
+            components: [
+              { name: 'amount', type: 'uint256' },
+              { name: 'receiver', type: 'address' },
+              { name: 'token', type: 'address' },
+            ],
+            name: 'extraTransfers',
+            type: 'tuple[]',
+          },
+          {
+            components: [
+              { name: 'amount', type: 'uint256' },
+              { name: 'receiver', type: 'address' },
+              { name: 'token', type: 'address' },
+            ],
+            name: 'requestedOutput',
+            type: 'tuple',
+          },
+          { name: 'user', type: 'address' },
+        ],
+        name: 'order',
+        type: 'tuple',
+      },
+    ],
+    name: 'cancelManuallyCreatedOrder',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+const PERMIT2_INVALIDATE_NONCES_ABI = [
+  {
+    inputs: [
+      { name: 'wordPos', type: 'uint256' },
+      { name: 'mask', type: 'uint256' },
+    ],
+    name: 'invalidateUnorderedNonces',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+export function getCancelCrossChainOrderRawData(params: CancelCrossChainOrderParams): Hex {
+  const orderInfo = {
+    user: params.user as Hex,
+    tokenIn: params.tokenIn as Hex,
+    srcChainId: BigInt(params.srcChainId),
+    deadline: BigInt(params.deadline),
+    amountIn: params.amountIn,
+    minStablecoinsAmount: params.minStablecoinsAmount,
+    executionDetailsHash: params.executionDetailsHash as Hex,
+    nonce: params.nonce,
+  };
+
+  return encodeFunctionData({
+    abi: CROSS_CHAIN_CANCEL_ORDER_ABI,
+    functionName: 'cancelOrder',
+    args: [orderInfo],
+  });
+}
+
+export function getCancelSingleChainOrderRawData(params: CancelSingleChainOrderParams): Hex {
+  const order = {
+    amountIn: params.amountIn,
+    tokenIn: params.tokenIn as Hex,
+    deadline: BigInt(params.deadline),
+    nonce: params.nonce,
+    encodedExternalCallData: params.encodedExternalCallData as Hex,
+    extraTransfers: params.extraTransfers.map((transfer) => ({
+      amount: transfer.amount,
+      receiver: transfer.receiver as Hex,
+      token: transfer.token as Hex,
+    })),
+    requestedOutput: {
+      amount: params.requestedOutput.amount,
+      receiver: params.requestedOutput.receiver as Hex,
+      token: params.requestedOutput.token as Hex,
+    },
+    user: params.user as Hex,
+  };
+
+  return encodeFunctionData({
+    abi: SINGLE_CHAIN_CANCEL_ORDER_ABI,
+    functionName: 'cancelManuallyCreatedOrder',
+    args: [order],
+  });
+}
+
+export function getInvalidateNoncesRawData(nonce: bigint): Hex {
+  const nonceWordPos = nonce >> 8n;
+  const nonceBitPos = nonce - nonceWordPos * 256n;
+  const mask = 1n << nonceBitPos;
+
+  return encodeFunctionData({
+    abi: PERMIT2_INVALIDATE_NONCES_ABI,
+    functionName: 'invalidateUnorderedNonces',
+    args: [nonceWordPos, mask],
+  });
+}

package/src/core/evm/{viem-provider.ts → chain-provider.ts}

@@ -18,11 +18,14 @@ import type { EVMConfig } from '../../config.js';
 import { ERC20ABI } from './abi/erc20.js';
 import { SOURCE_CHAIN_GUARD_ABI } from './abi/source-chain-guard.js';
 import { PERMIT2_ABI } from './abi/permit2.js';
+import { SINGLE_CHAIN_GUARD_LIMIT_ABI } from './abi/single-chain-guard-limit.js';
+import { hyperEVM } from './connectors/hyperevm.js';
 
-const chainIdToProviderChainMap = {
+export const chainIdToProviderChainMap: Record<SupportedEvmChain, Chain> = {
   [ChainID.Arbitrum]: arbitrum,
   [ChainID.Optimism]: optimism,
   [ChainID.Base]: base,
+  [ChainID.Hyperliquid]: hyperEVM,
 };
 
 export class ChainProvider {
@@ -79,8 +82,21 @@ export class ChainProvider {
     });
   }
 
+  getSingleChainAuctioneerContract(address: Address) {
+    return getContract({
+      address: address,
+      abi: SINGLE_CHAIN_GUARD_LIMIT_ABI,
+      client: {
+        wallet: this.walletClient,
+        public: this.publicClient,
+        chain: chainIdToProviderChainMap[this.chainId],
+        account: this.walletClient.account,
+      },
+    });
+  }
+
   // Any type since the inferred type of this node exceeds the maximum length the compiler will serialize
-  getAuctioneerContract(auctioneerAddress: Address): any {
+  getCrossChainAuctioneerContract(auctioneerAddress: Address): any {
     return getContract({
       address: auctioneerAddress,
       abi: SOURCE_CHAIN_GUARD_ABI,

package/src/core/evm/connectors/hyperevm.ts

@@ -0,0 +1,23 @@
+import { defineChain } from 'viem';
+
+export const hyperEVM = defineChain({
+  id: 999,
+  name: 'HyperEVM',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'HyperEVM',
+    symbol: 'HYPE',
+  },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.hyperliquid.xyz/evm'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'HyperEVM Explorer',
+      url: 'https://hyperevmscan.io/', 
+    },
+  },
+  testnet: false,
+});

package/src/core/evm/intent-provider.ts

@@ -1,22 +1,23 @@
 import { type Address } from 'viem';
 import { type SupportedEvmChain } from '../../chains.js';
 import type { EVMConfig } from '../../config.js';
-import { SRC_CHAIN_GUARD } from '../../constants.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import type { Order } from '../order.js';
-import { getEvmOrderTypedData } from './order-signature.js';
-import { type PermitTransferFrom } from './permit2.js';
-import { ChainProvider } from './viem-provider.js';
+import { SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, MAX_UINT_32 } from '../../constants.js';
+import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './order-signature.js';
+import { type CrossChainPermitTransferFrom, type SingleChainPermitTransferFrom, type TransferData } from './permit2.js';
+import { ChainProvider } from './chain-provider.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
 
 export class EVMIntentProvider {
-  public provider: ChainProvider;
+  provider: ChainProvider;
 
   constructor(config: EVMConfig) {
     this.provider = new ChainProvider(config);
   }
 
-  async prepare(order: Order): Promise<PreparedOrder> {
-    const { orderTypedData: dataToSign, nonce } = await getEvmOrderTypedData(order);
+  async prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared> {
+    const { orderTypedData: dataToSign, nonce } = await getEVMSingleChainOrderTypedData(order);
 
     const signature = await this.provider.walletClient.signTypedData({
       message: dataToSign.message,
@@ -35,13 +36,35 @@ export class EVMIntentProvider {
     };
   }
 
-  static getPermissionMessage(order: Order, nonce: bigint): PermitTransferFrom {
+  async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+    const { orderTypedData: dataToSign, nonce } = await getEVMCrossChainOrderTypedData(order);
+
+    const signature = await this.provider.walletClient.signTypedData({
+      message: dataToSign.message,
+      primaryType: dataToSign.primaryType,
+      types: dataToSign.types,
+      domain: dataToSign.domain,
+      account: this.provider.getAccount(),
+    });
+
+    return {
+      order,
+      preparedData: {
+        nonce: nonce.toString(),
+        signature: signature.slice(2),
+      },
+    };
+  }
+
+  static getCrossChainPermissionMessage(order: CrossChainOrder, nonce: bigint): CrossChainPermitTransferFrom {
+    const spender = CROSS_CHAIN_GUARD_ADDRESSES[order.sourceChainId as SupportedEvmChain] as Address;
+
     return {
       permitted: {
         token: order.sourceTokenAddress as Address,
         amount: order.sourceTokenAmount,
       },
-      spender: SRC_CHAIN_GUARD[order.sourceChainId as SupportedEvmChain] as Address,
+      spender,
       nonce,
       deadline: BigInt(order.deadline),
       witness: {
@@ -57,7 +80,43 @@ export class EVMIntentProvider {
     };
   }
 
+  static getSingleChainLimitPermissionMessage(order: SingleChainOrder, nonce: bigint): SingleChainPermitTransferFrom {
+    const spender = SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId as SupportedEvmChain] as Address;
+
+    const requestedOutput: TransferData = {
+      token: order.tokenOut as Address,
+      receiver: order.destinationAddress as Address,
+      amount: order.amountOutMin,
+    };
+
+    const extraTransfers: TransferData[] =
+      order.extraTransfers?.map((transfer) => ({
+        token: transfer.token as Address,
+        receiver: transfer.receiver as Address,
+        amount: transfer.amount,
+      })) || [];
+
+    return {
+      permitted: {
+        token: order.tokenIn as Address,
+        amount: order.amountIn,
+      },
+      spender,
+      nonce,
+      deadline: BigInt(order.deadline),
+      witness: {
+        user: order.user as Address,
+        tokenIn: order.tokenIn as Address,
+        amountIn: order.amountIn,
+        requestedOutput,
+        encodedExternalCallData: '0x', // TODO: Update when external call data is supported
+        extraTransfers,
+        deadline: order.deadline,
+        nonce,
+      },
+    };
+  }
   static getRandomNonce(): bigint {
-    return BigInt(Math.floor(Math.random() * 1000000000000));
+    return BigInt(Math.floor(Math.random() * Number(MAX_UINT_32)));
   }
 }

package/src/core/evm/order-signature.ts

@@ -1,56 +1,43 @@
-import type { TypedDataDomain } from 'viem';
+import type { TypedDataDefinition } from 'viem';
 import type { SupportedEvmChain } from '../../chains.js';
-import type { Order } from '../order.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
 import { EVMIntentProvider } from './intent-provider.js';
-import { PERMIT2_DOMAIN, PERMIT2_TYPES, type PermitTransferFrom } from './permit2.js';
-import type { ApiResponse } from '../../types/api.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { BaseSDK } from '../sdk.js';
+import { CROSS_CHAIN_PERMIT2_TYPES, PERMIT2_DOMAIN, SINGLE_CHAIN_LIMIT_PERMIT2_TYPES } from './permit2.js';
+import type { SingleChainOrder } from '../orders/single-chain.js';
 
-export type EvmOrderTypedData = {
-  domain: TypedDataDomain;
-  types: typeof PERMIT2_TYPES;
-  primaryType: 'PermitWitnessTransferFrom';
-  message: PermitTransferFrom;
-};
+export async function getEVMSingleChainOrderTypedData(
+  order: SingleChainOrder,
+): Promise<{ orderTypedData: TypedDataDefinition; nonce: bigint }> {
+  const randomNonce = EVMIntentProvider.getRandomNonce();
+  const permissionMessage = EVMIntentProvider.getSingleChainLimitPermissionMessage(order, randomNonce);
+
+  const orderTypedData = {
+    domain: PERMIT2_DOMAIN(order.chainId as SupportedEvmChain),
+    types: SINGLE_CHAIN_LIMIT_PERMIT2_TYPES,
+    primaryType: 'PermitWitnessTransferFrom',
+    message: permissionMessage,
+  };
+
+  return { orderTypedData, nonce: randomNonce };
+}
 
 /**
  * Generates typed data for EVM order signatures
  * @param order The order to generate typed data for
  * @returns Object containing the typed data and nonce
  */
-export async function getEvmOrderTypedData(
-  order: Order,
-): Promise<{ orderTypedData: EvmOrderTypedData; nonce: bigint }> {
+export async function getEVMCrossChainOrderTypedData(
+  order: CrossChainOrder,
+): Promise<{ orderTypedData: TypedDataDefinition; nonce: bigint }> {
   const randomNonce = EVMIntentProvider.getRandomNonce();
-  const permissionMessage = EVMIntentProvider.getPermissionMessage(order, randomNonce);
+  const permissionMessage = EVMIntentProvider.getCrossChainPermissionMessage(order, randomNonce);
 
   const orderTypedData = {
     domain: PERMIT2_DOMAIN(order.sourceChainId as SupportedEvmChain),
-    types: PERMIT2_TYPES,
+    types: CROSS_CHAIN_PERMIT2_TYPES,
     primaryType: 'PermitWitnessTransferFrom',
     message: permissionMessage,
-  } as EvmOrderTypedData;
-
-  return { orderTypedData, nonce: randomNonce };
-}
-
-export async function sendEvmRequest({
-  order,
-  signature,
-  nonce,
-}: {
-  order: Order;
-  signature: string;
-  nonce: bigint;
-}): Promise<ApiResponse> {
-  const preparedOrder: PreparedOrder = {
-    order,
-    preparedData: {
-      signature,
-      nonce: nonce.toString(),
-    },
   };
 
-  return BaseSDK.sendOrder(preparedOrder);
+  return { orderTypedData, nonce: randomNonce };
 }

package/src/core/evm/permit2.ts

@@ -7,7 +7,13 @@ export type TokenPermissions = {
   amount: bigint;
 };
 
-export type OrderInfo = {
+export type TransferData = {
+  token: Address;
+  receiver: Address;
+  amount: bigint;
+};
+
+export type CrossChainOrderInfo = {
   user: Address;
   tokenIn: Address;
   srcChainId: number;
@@ -18,21 +24,63 @@ export type OrderInfo = {
   nonce: bigint;
 };
 
-export type PermitTransferFrom = {
+export type SingleChainLimitOrder = {
+  user: Address;
+  tokenIn: Address;
+  amountIn: bigint;
+  requestedOutput: TransferData;
+  extraTransfers: TransferData[];
+  encodedExternalCallData: Hex;
+  deadline: number;
+  nonce: bigint;
+};
+
+export type DcaOrderInfo = {
+  user: Address;
+  tokenIn: Address;
+  srcChainId: number;
+  startTime: number;
+  deadline: number;
+  totalIntervals: number;
+  intervalDuration: number;
+  amountInPerInterval: bigint;
+  minStablecoinsAmountPerInterval: bigint;
+  executionDetailsHash: Hex;
+  nonce: bigint;
+};
+
+export type CrossChainPermitTransferFrom = {
   permitted: TokenPermissions;
   spender: Address;
   nonce: bigint;
   deadline: bigint;
-  witness: OrderInfo;
+  witness: CrossChainOrderInfo;
 };
 
-const TOKEN_PERMISSIONS = [
+export type SingleChainPermitTransferFrom = {
+  permitted: TokenPermissions;
+  spender: Address;
+  nonce: bigint;
+  deadline: bigint;
+  witness: SingleChainLimitOrder;
+};
+
+export type PermitTransferFrom = CrossChainPermitTransferFrom | SingleChainPermitTransferFrom;
+
+const TOKEN_PERMISSIONS_TYPE = [
   { name: 'token', type: 'address' },
   { name: 'amount', type: 'uint256' },
 ] as const;
 
-export const PERMIT2_TYPES = {
-  TokenPermissions: TOKEN_PERMISSIONS,
+const TRANSFER_DATA_TYPE = [
+  { name: 'token', type: 'address' },
+  { name: 'receiver', type: 'address' },
+  { name: 'amount', type: 'uint256' },
+] as const;
+
+// Cross-chain order types
+export const CROSS_CHAIN_PERMIT2_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS_TYPE,
   OrderInfo: [
     { name: 'user', type: 'address' },
     { name: 'tokenIn', type: 'address' },
@@ -52,9 +100,31 @@ export const PERMIT2_TYPES = {
   ],
 } as const;
 
-export const PERMIT2_DOMAIN = (chainId: SupportedEvmChain) =>
-  ({
-    name: 'Permit2',
-    chainId,
-    verifyingContract: PERMIT2_ADDRESS[chainId],
-  }) as TypedDataDomain;
+// Single-chain limit order types
+export const SINGLE_CHAIN_LIMIT_PERMIT2_TYPES = {
+  TokenPermissions: TOKEN_PERMISSIONS_TYPE,
+  TransferData: TRANSFER_DATA_TYPE,
+  SingleChainLimitOrder: [
+    { name: 'user', type: 'address' },
+    { name: 'tokenIn', type: 'address' },
+    { name: 'amountIn', type: 'uint256' },
+    { name: 'requestedOutput', type: 'TransferData' },
+    { name: 'extraTransfers', type: 'TransferData[]' },
+    { name: 'encodedExternalCallData', type: 'bytes' },
+    { name: 'deadline', type: 'uint32' },
+    { name: 'nonce', type: 'uint256' },
+  ],
+  PermitWitnessTransferFrom: [
+    { name: 'permitted', type: 'TokenPermissions' },
+    { name: 'spender', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'witness', type: 'SingleChainLimitOrder' },
+  ],
+} as const;
+
+export const PERMIT2_DOMAIN = (chainId: SupportedEvmChain): TypedDataDomain => ({
+  name: 'Permit2',
+  chainId,
+  verifyingContract: PERMIT2_ADDRESS[chainId],
+});