@shogun-sdk/intents-sdk 1.0.1 → 1.1.0

package/src/chains.ts

@@ -1,4 +1,3 @@
-import { NATIVE_EVM_ETH_ADDRESSES } from './constants.js';
 import type { TupleToUnion } from './utils/type-utils.js';
 
 /**
@@ -20,6 +19,7 @@ export enum ChainID {
   Arbitrum = 42161,
   Optimism = 10,
   Base = 8453,
+  Hyperliquid = 999,
   Solana = 7565164,
   Sui = 101,
 }
@@ -28,7 +28,14 @@ export enum ChainID {
  * Array of chain IDs that are supported by the SDK
  * Used as a source of truth for type generation
  */
-export const SupportedChains = [ChainID.Arbitrum, ChainID.Base, ChainID.Optimism, ChainID.Solana, ChainID.Sui] as const;
+export const SupportedChains = [
+  ChainID.Arbitrum,
+  ChainID.Base,
+  ChainID.Optimism,
+  ChainID.Hyperliquid,
+  ChainID.Solana,
+  ChainID.Sui,
+] as const;
 
 /**
  * Type utility to identify chains not in the SupportedChains array
@@ -42,28 +49,23 @@ type UnsupportedChain = Exclude<ChainID, TupleToUnion<typeof SupportedChains>>;
  */
 export type SupportedChain = Exclude<ChainID, UnsupportedChain>;
 
-/**
- * Type representing EVM chains that are supported by the SDK
- * Includes Arbitrum, Base, and Optimism
- */
-export type SupportedEvmChain = Exclude<ChainID, TupleToUnion<[ChainID.Solana, ChainID.Sui]>>;
-
-/**
- * Type alias for Solana chain ID
- */
-export type SupportedSolanaChain = ChainID.Solana;
+export type SupportedSolanaChain = 7565164;
+export type SupportedSuiChain = 101;
+export type SupportedEvmChain = Exclude<ChainID, SupportedSolanaChain | SupportedSuiChain>;
 
-/**
- * Type alias for Sui chain ID
- */
-export type SupportedSuiChain = ChainID.Sui;
+export function isEvmChain(chainId: ChainID): chainId is SupportedEvmChain {
+  return chainId !== ChainID.Solana && chainId !== ChainID.Sui;
+}
 
 /**
  * Type guard that checks if a chain ID is among the supported chains
  * @param chain - The chain ID to check
  * @returns Boolean indicating if the chain is supported
  */
-export const isSupportedChain = (chain: unknown): chain is SupportedChain => SupportedChains.includes(chain as number);
+export const isSupportedChain = (chain: unknown): chain is SupportedChain => {
+  if (typeof chain !== 'number') return false;
+  return (SupportedChains as readonly number[]).includes(chain);
+};
 
 /**
  * Maps chain IDs to their corresponding chain types
@@ -73,12 +75,7 @@ export const chainIdToChainTypeMap = {
   [ChainID.Arbitrum]: ChainType.EVM,
   [ChainID.Base]: ChainType.EVM,
   [ChainID.Optimism]: ChainType.EVM,
+  [ChainID.Hyperliquid]: ChainType.EVM,
   [ChainID.Solana]: ChainType.Solana,
   [ChainID.Sui]: ChainType.Sui,
 } as const;
-
-export function isNativeTokenEvmAddress(tokenAddress: string): boolean {
-  const normalizedAddress = tokenAddress.toLowerCase();
-
-  return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
-}

package/src/constants.ts

@@ -1,53 +1,93 @@
 import { address, type Address as SolanaAddress } from '@solana/kit';
 import type { Address, Hex } from 'viem';
-import type { SupportedChain, SupportedEvmChain } from './chains.js';
+import type { SupportedChain, SupportedEvmChain, SupportedSuiChain } from './chains.js';
 import { ChainID } from './chains.js';
 
+const useProdConfig = true;
+
+export enum OrderType {
+  CROSS_CHAIN_LIMIT = 'CROSS_CHAIN_LIMIT',
+  SINGLE_CHAIN_LIMIT = 'SINGLE_CHAIN_LIMIT',
+}
+
 export const PERMIT2_ADDRESS: Record<SupportedEvmChain, Address> = {
   [ChainID.Arbitrum]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
   [ChainID.Optimism]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
   [ChainID.Base]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
+  [ChainID.Hyperliquid]: '0x000000000022d473030f116ddee9f6b43ac78ba3' as Address,
 };
 
-// export const SRC_CHAIN_GUARD: Record<SupportedChain, SolanaAddress | Hex> = {
-//   [ChainID.Arbitrum]: '0x921ab91ee3dc38fd47aefd6218fd6b0bd9d64c18' as Address,
-//   [ChainID.Optimism]: '0xa89b2aae94769bf4a5dc9982eabe2c513564d1ea' as Address,
-//   [ChainID.Base]: '0x5173e9f12e2485f990ce4dac877d8545fb4ec81a' as Address,
-//   [ChainID.Solana]: address('4kD6otCKkKZQej8YNQkWdzG9xMo5XYN8T1BbUrJUE63E'),
-//   [ChainID.Sui]:
-//     '0x88a47715f41c5e47ff6d6dcfc0285f3802ae1587a9f411d0daff20269245a1b0',
-// }
+// Production guard addresses
+export const PROD_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | Hex> = {
+  [ChainID.Arbitrum]: '0x921ab91ee3dc38fd47aefd6218fd6b0bd9d64c18' as Address,
+  [ChainID.Optimism]: '0xa89b2aae94769bf4a5dc9982eabe2c513564d1ea' as Address,
+  [ChainID.Base]: '0x5173e9f12e2485f990ce4dac877d8545fb4ec81a' as Address,
+  [ChainID.Hyperliquid]: '0x6595bcc70e0c34ecf9174bb72881eea89b075021' as Address,
+  [ChainID.Solana]: address('4kD6otCKkKZQej8YNQkWdzG9xMo5XYN8T1BbUrJUE63E'),
+  [ChainID.Sui]: '0x88a47715f41c5e47ff6d6dcfc0285f3802ae1587a9f411d0daff20269245a1b0',
+};
 
-export const SRC_CHAIN_GUARD: Record<SupportedChain, SolanaAddress | Hex> = {
+// Test guard addresses
+export const TEST_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, SolanaAddress | Hex> = {
   [ChainID.Arbitrum]: '0x8cfacbe4e236c0ca0a7b4b9fc5b696aa9f07cc41' as Address,
   [ChainID.Optimism]: '0x66fbcccbd3ffe2d347bc2776ef8a6561ff29998e' as Address,
   [ChainID.Base]: '0xa895a53634854756ae8e902065e3be26ee36381d' as Address,
+  [ChainID.Hyperliquid]: '0xB8ec423b5f03b138Ad47c85Ea5F7AAEBB116D65e' as Address,
   [ChainID.Solana]: address('FAKnXTY7cNz9wMTpH1wwsU9a1xzBAiMwAn2NXmGMLynP'),
   [ChainID.Sui]: '0xd5057237ba5fe3d9aa00bb2a1555c3d3de77fd5653e72ce70f4aa0561fa9f04d',
 };
 
-// export const SRC_CHAIN_GUARD_TEST: Record<SupportedChain, SolanaAddress | Hex> =
-//   {
-//     [ChainID.Arbitrum]: '0x8cfacbe4e236c0ca0a7b4b9fc5b696aa9f07cc41' as Address,
-//     [ChainID.Optimism]: '0x66fbcccbd3ffe2d347bc2776ef8a6561ff29998e' as Address,
-//     [ChainID.Base]: '0xa895a53634854756ae8e902065e3be26ee36381d' as Address,
-//     [ChainID.Solana]: address('FAKnXTY7cNz9wMTpH1wwsU9a1xzBAiMwAn2NXmGMLynP'),
-//     [ChainID.Sui]:
-//       '0xd5057237ba5fe3d9aa00bb2a1555c3d3de77fd5653e72ce70f4aa0561fa9f04d',
-//   }
+// Prod guard addresses
+export const PROD_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, SolanaAddress | Hex> = {
+  [ChainID.Arbitrum]: '0x0' as Address,
+  [ChainID.Optimism]: '0x0' as Address,
+  [ChainID.Base]: '0x449808a27f42518c57791d4c2c6626f0069a0ed9' as Address,
+  [ChainID.Hyperliquid]: '0x618ee9b6829261108d811b91581e00da192b0b75' as Address,
+  [ChainID.Solana]: address('CwWkajHjBCWMKZdwR5D1P5M6Fgf9dAyxqZ1qDZgZGo1e'),
+};
 
-export const NATIVE_EVM_ETH_ADDRESSES = [
-  '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
-  '0x0000000000000000000000000000000000000000',
-];
+// Test guard addresses
+export const TEST_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, SolanaAddress | Hex> = {
+  [ChainID.Arbitrum]: '0x0' as Address,
+  [ChainID.Optimism]: '0x0' as Address,
+  [ChainID.Base]: '0x5602cedc725564694162a320c5bb91b5b4b25fca' as Address,
+  [ChainID.Hyperliquid]: '0x6a2f41f905035fa89b7329c0661061b580b1eb92' as Address,
+  [ChainID.Solana]: address('4wi5wsgSs9q9WV55s9AvKWTdeMNPcDXhzcbx5SoRRFcg'),
+};
 
-export const NATIVE_SOLANA_TOKEN_ADDRESS = address('So11111111111111111111111111111111111111111');
+export const CROSS_CHAIN_GUARD_ADDRESSES = useProdConfig
+  ? PROD_CROSS_CHAIN_GUARD_ADDRESSES
+  : TEST_CROSS_CHAIN_GUARD_ADDRESSES;
+export const SINGLE_CHAIN_GUARD_ADDRESSES = useProdConfig
+  ? PROD_SINGLE_CHAIN_GUARD_ADDRESSES
+  : TEST_SINGLE_CHAIN_GUARD_ADDRESSES;
 
+export const NATIVE_SOLANA_TOKEN_ADDRESS = address('So11111111111111111111111111111111111111111');
 export const WRAPPED_SOL_MINT_ADDRESS = address('So11111111111111111111111111111111111111112');
 
-export const SUI_PACKAGE_ID = '0x6273e29f803ff5851f89ec17d40d5b1f367476e1677ad0a52ca408f64c4473fe';
+type SolanaMint = {
+  name: string;
+  mint: string;
+  decimals: number;
+};
 
-// export const TEST_SUI_PACKAGE_ID = '0x6273e29f803ff5851f89ec17d40d5b1f367476e1677ad0a52ca408f64c4473fe'
+export const SOLANA_USDC_MINT = {
+  name: 'USDC',
+  mint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+  decimals: 6,
+} as SolanaMint;
+
+export const SOLANA_USDT_MINT = {
+  name: 'USDT',
+  mint: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+  decimals: 6,
+} as SolanaMint;
+
+export const SOLANA_MINT_TOKEN = useProdConfig ? SOLANA_USDC_MINT : SOLANA_USDT_MINT;
+
+export const PROD_SUI_PACKAGE_ID = '0x9c0c9b7f5ddf7efbde76571783ef4a8a26b36ae5c2ef2eeba8fbc604a29cb195';
+export const TEST_SUI_PACKAGE_ID = '0x6273e29f803ff5851f89ec17d40d5b1f367476e1677ad0a52ca408f64c4473fe';
+export const SUI_PACKAGE_ID = useProdConfig ? PROD_SUI_PACKAGE_ID : TEST_SUI_PACKAGE_ID;
 
 export const SUI_GUARD_COLLATERAL_TYPE =
   '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
@@ -55,16 +95,30 @@ export const SUI_GUARD_COLLATERAL_TYPE =
 export const SUI_GUARD_STABLECOIN_TYPE =
   '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
 
-/**
- * URL of the auctioneer service endpoint
- */
-// export const AUCTIONEER_URL = 'https://auctioneer-825534211396.us-central1.run.app'
-export const AUCTIONEER_URL = 'http://127.0.0.1:8080';
+export const AUCTIONEER_URL = useProdConfig
+  ? 'https://auctioneer-825534211396.us-central1.run.app'
+  : 'http://127.0.0.1:8080';
 
+export const MAX_UINT_32 = 2n ** 32n - 1n;
 export const MAX_UINT_64 = 2n ** 64n - 1n;
 export const MAX_UINT_128 = 2n ** 128n - 1n;
 export const MAX_UINT_256 = 2n ** 256n - 1n;
 
-// Amount Calculation constants
-export const REDUCTION_FACTOR = 0.8; // 80% of the input value
-export const STABLECOIN_DECIMALS = 6; // USDC/USDT typically use 6 decimals
+export const NATIVE_EVM_ETH_ADDRESSES = [
+  '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+  '0x0000000000000000000000000000000000000000',
+];
+
+export const WRAPPED_ETH_ADDRESSES: Record<SupportedEvmChain, Address> = {
+  [ChainID.Arbitrum]: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1' as Address,
+  [ChainID.Optimism]: '0x4200000000000000000000000000000000000006' as Address,
+  [ChainID.Base]: '0x4200000000000000000000000000000000000006' as Address,
+  [ChainID.Hyperliquid]: '0x5555555555555555555555555555555555555555' as Address,
+};
+
+export const NATIVE_SUI_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+export function isNativeEvmToken(tokenAddress: string): boolean {
+  const normalizedAddress = tokenAddress.toLowerCase();
+
+  return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
+}

package/src/core/evm/abi/permit2.ts

@@ -0,0 +1,394 @@
+export const PERMIT2_ABI = [
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'maxAmount',
+        type: 'uint256',
+      },
+    ],
+    name: 'InvalidAmount',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'LengthMismatch',
+    type: 'error',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'word',
+        type: 'uint256',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'mask',
+        type: 'uint256',
+      },
+    ],
+    name: 'UnorderedNonceInvalidation',
+    type: 'event',
+  },
+  {
+    inputs: [],
+    name: 'DOMAIN_SEPARATOR',
+    outputs: [
+      {
+        internalType: 'bytes32',
+        name: '',
+        type: 'bytes32',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'wordPos',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'mask',
+        type: 'uint256',
+      },
+    ],
+    name: 'invalidateUnorderedNonces',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    name: 'nonceBitmap',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions',
+            name: 'permitted',
+            type: 'tuple',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails',
+        name: 'transferDetails',
+        type: 'tuple',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions[]',
+            name: 'permitted',
+            type: 'tuple[]',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitBatchTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails[]',
+        name: 'transferDetails',
+        type: 'tuple[]',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions',
+            name: 'permitted',
+            type: 'tuple',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails',
+        name: 'transferDetails',
+        type: 'tuple',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'witness',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'string',
+        name: 'witnessTypeString',
+        type: 'string',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitWitnessTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: 'address',
+                name: 'token',
+                type: 'address',
+              },
+              {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            internalType: 'struct ISignatureTransfer.TokenPermissions[]',
+            name: 'permitted',
+            type: 'tuple[]',
+          },
+          {
+            internalType: 'uint256',
+            name: 'nonce',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'deadline',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.PermitBatchTransferFrom',
+        name: 'permit',
+        type: 'tuple',
+      },
+      {
+        components: [
+          {
+            internalType: 'address',
+            name: 'to',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'requestedAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct ISignatureTransfer.SignatureTransferDetails[]',
+        name: 'transferDetails',
+        type: 'tuple[]',
+      },
+      {
+        internalType: 'address',
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'witness',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'string',
+        name: 'witnessTypeString',
+        type: 'string',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'permitWitnessTransferFrom',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;