@sodax/dapp-kit 0.0.1-rc.3 → 0.0.1-rc.30

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Sodax]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -10,23 +10,59 @@ dApp Kit is a collection of React components, hooks, and utilities designed to s
   - Withdraw tokens from the money market (`useWithdraw`)
   - Borrow tokens from the money market (`useBorrow`)
   - Repay borrowed tokens (`useRepay`)
+  - Check token allowance (`useMMAllowance`)
+  - Approve token spending (`useMMApprove`)
   - Get user reserves data (`useUserReservesData`)
-  - Calculate hub wallet address by using spoke chain id and spoke chain wallet address (`useHubWalletAddress`)
+  - Get reserves data (`useReservesData`)
+  - Get humanized reserves data (`useReservesHumanized`)
+  - Get list of reserves (`useReservesList`)
+  - Get USD formatted reserves data (`useReservesUsdFormat`)
+  - Get formatted user portfolio summary (`useUserFormattedSummary`)
 
 - Swap/Intent
   - Get quote for an intent order (`useQuote`)
-  - Create and submit an intent order (`useCreateIntentOrder`)
+  - Create and submit an swap intent order (`useSwap`)
   - Get status of an intent order (`useStatus`)
+  - Check token allowance (`useSwapAllowance`)
+  - Approve token spending (`useSwapApprove`)
+  - Cancel a swap intent order (`useCancelSwap`)
 
 - Provider
   - Get hub chain provider (`useHubProvider`)
   - Get spoke chain provider (`useSpokeProvider`)
   - Get wallet provider (`useWalletProvider`)
 
-- Token Management
-  - Check token allowance (`useAllowance`)
-  - Approve token spending (`useApprove`)
-
+- Bridge
+  - Bridge tokens between chains (`useBridge`)
+  - Check token allowance for bridging (`useBridgeAllowance`)
+  - Approve source token for bridging (`useBridgeApprove`)
+  - Get max amount available to be bridged (`useGetBridgeableAmount`)
+  - Get available destination tokens based on provided source token (`useGetBridgeableTokens`)
+
+- Shared
+  - Derive user wallet address for hub abstraction (`useDeriveUserWalletAddress`)
+  - Check if Stellar trustline is established for an asset (`useStellarTrustlineCheck`)
+  - Request creation of Stellar trustline line for an asset (`useRequestTrustline`)
+
+- Staking
+  - Stake SODA tokens to receive xSODA shares (`useStake`)
+  - Unstake xSODA shares (`useUnstake`)
+  - Instant unstake xSODA shares with penalty (`useInstantUnstake`)
+  - Claim unstaked SODA tokens after unstaking period (`useClaim`)
+  - Cancel unstake request (`useCancelUnstake`)
+  - Check SODA token allowance for staking (`useStakeAllowance`)
+  - Approve SODA token spending for staking (`useStakeApprove`)
+  - Check xSODA token allowance for unstaking (`useUnstakeAllowance`)
+  - Approve xSODA token spending for unstaking (`useUnstakeApprove`)
+  - Check xSODA token allowance for instant unstaking (`useInstantUnstakeAllowance`)
+  - Approve xSODA token spending for instant unstaking (`useInstantUnstakeApprove`)
+  - Get comprehensive staking information (`useStakingInfo`)
+  - Get unstaking information with penalty details (`useUnstakingInfoWithPenalty`)
+  - Get unstaking information (`useUnstakingInfo`)
+  - Get staking configuration (`useStakingConfig`)
+  - Get stake ratio (SODA to xSODA conversion rate) (`useStakeRatio`)
+  - Get instant unstake ratio (xSODA to SODA conversion rate with penalty) (`useInstantUnstakeRatio`)
+  - Get converted assets amount for xSODA shares (`useConvertedAssets`)
 
 ## Installation
 
@@ -43,56 +79,43 @@ pnpm add @sodax/dapp-kit
 1. First, install the required dependencies:
 
 ```bash
-npm install @sodax/dapp-kit @tanstack/react-query @sodax/wallet-sdk
+pnpm install @sodax/dapp-kit @tanstack/react-query @sodax/wallet-sdk-react
 ```
 
 2. Set up the providers in your app:
 
 ```typescript
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { XWagmiProviders } from '@sodax/wallet-sdk';
+import { SodaxWalletProvider } from '@sodax/wallet-sdk-react';
 import { SodaxProvider } from '@sodax/dapp-kit';
-import { SONIC_MAINNET_CHAIN_ID } from '@sodax/types';
+import type { RpcConfig } from '@sodax/types';
 
 const queryClient = new QueryClient();
 
-// Configure Sodax
-const sodaxConfig = {
-  hubProviderConfig: {
-    hubRpcUrl: 'https://rpc.soniclabs.com',
-    chainConfig: getHubChainConfig(SONIC_MAINNET_CHAIN_ID),
-  },
-  moneyMarket: getMoneyMarketConfig(SONIC_MAINNET_CHAIN_ID),
-  solver: {
-    intentsContract: '0x6382D6ccD780758C5e8A6123c33ee8F4472F96ef',
-    solverApiEndpoint: 'https://staging-new-world.iconblockchain.xyz',
-    partnerFee: {
-      address: '0x0Ab764AB3816cD036Ea951bE973098510D8105A6',
-      percentage: 100, // 1%
-    },
-  },
-  relayerApiEndpoint: 'https://xcall-relay.nw.iconblockchain.xyz',
+const rpcConfig: RpcConfig = {
+  // EVM chains
+  sonic: 'https://rpc.soniclabs.com',
+  '0xa86a.avax': 'https://api.avax.network/ext/bc/C/rpc',
+  '0xa4b1.arbitrum': 'https://arb1.arbitrum.io/rpc',
+  '0x2105.base': 'https://mainnet.base.org',
+  '0x38.bsc': 'https://bsc-dataseed1.binance.org',
+  '0xa.optimism': 'https://mainnet.optimism.io',
+  '0x89.polygon': 'https://polygon-rpc.com',
+  
+  // Other chains
+  '0x1.icon': 'https://ctz.solidwallet.io/api/v3',
+  solana: 'https://solana-mainnet.g.alchemy.com/v2/your-api-key',
+  sui: 'https://fullnode.mainnet.sui.io',
+  'injective-1': 'https://sentry.tm.injective.network:26657',
 };
 
 function App() {
   return (
-    <SodaxProvider testnet={false} config={sodaxConfig}>
+    <SodaxProvider testnet={false} rpcConfig={rpcConfig}>
       <QueryClientProvider client={queryClient}>
-        <XWagmiProviders
-          config={{
-            EVM: {
-              wagmiConfig: wagmiConfig,
-            },
-            SUI: {
-              isMainnet: true,
-            },
-            SOLANA: {
-              endpoint: 'https://solana-mainnet.g.alchemy.com/v2/your-api-key',
-            },
-          }}
-        >
+        <SodaxWalletProvider rpcConfig={rpcConfig}>
           <YourApp />
-        </XWagmiProviders>
+        </SodaxWalletProvider>
       </QueryClientProvider>
     </SodaxProvider>
   );
@@ -103,7 +126,7 @@ function App() {
 
 ```typescript
 // Connect Wallet Operations
-import { useXConnectors, useXConnect, useXAccount } from '@sodax/wallet-sdk';
+import { useXConnectors, useXConnect, useXAccount } from '@sodax/wallet-sdk-react';
 const evmConnectors = useXConnectors('EVM');
 const { mutateAsync: connect, isPending } = useXConnect();
 const account = useXAccount('EVM');
@@ -146,11 +169,11 @@ function MoneyMarketComponent() {
 }
 
 // Token Management
-import { useAllowance, useApprove } from '@sodax/dapp-kit';
+import { useMMAllowance, useApprove } from '@sodax/dapp-kit';
 
 function TokenManagementComponent() {
   // Check token allowance
-  const { data: hasAllowed } = useAllowance(token, amount);
+  const { data: hasAllowed } = useMMAllowance(token, amount);
   
   // Approve token spending
   const { approve, isLoading: isApproving } = useApprove(token);
@@ -159,8 +182,26 @@ function TokenManagementComponent() {
   };
 }
 
+// Wallet Address Derivation
+import { useDeriveUserWalletAddress, useSpokeProvider } from '@sodax/dapp-kit';
+
+function WalletAddressComponent() {
+  const spokeProvider = useSpokeProvider(chainId, walletProvider);
+  
+  // Derive user wallet address for hub abstraction
+  const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeProvider, userAddress);
+  
+  return (
+    <div>
+      {isLoading && <div>Deriving wallet address...</div>}
+      {error && <div>Error: {error.message}</div>}
+      {derivedAddress && <div>Derived Address: {derivedAddress}</div>}
+    </div>
+  );
+}
+
 // Swap Operations
-import { useQuote, useCreateIntentOrder, useStatus } from '@sodax/dapp-kit';
+import { useQuote, useSwap, useStatus } from '@sodax/dapp-kit';
 
 function SwapComponent() {
   // Get quote for an intent order
@@ -174,9 +215,9 @@ function SwapComponent() {
   });
 
   // Create and submit an intent order
-  const { mutateAsync: createOrder, isPending: isCreating } = useCreateIntentOrder();
-  const handleCreateOrder = async () => {
-    const order = await createOrder({
+  const { mutateAsync: swap, isPending: isCreating } = useSwap();
+  const handleSwap = async () => {
+    const order = await swap({
       token_src: '0x...',
       token_src_blockchain_id: '0xa86a.avax',
       token_dst: '0x...',
@@ -189,6 +230,53 @@ function SwapComponent() {
   // Get status of an intent order
   const { data: orderStatus } = useStatus('0x...');
 }
+
+// Bridge Operations
+import { useBridge, useBridgeAllowance, useBridgeApprove, useGetBridgeableAmount, useGetBridgeableTokens } from '@sodax/dapp-kit';
+
+function BridgeComponent() {
+  const spokeProvider = useSpokeProvider(chainId, walletProvider);
+  
+  // Get available destination tokens for bridging
+  const { data: bridgeableTokens, isLoading: isTokensLoading } = useGetBridgeableTokens(
+    '0x2105.base', // from chain
+    '0x89.polygon', // to chain
+    '0x...' // source token address
+  );
+
+  // Get maximum amount available to bridge
+  const { data: bridgeableAmount } = useGetBridgeableAmount(
+    { address: '0x...', xChainId: '0x2105.base' }, // from token
+    { address: '0x...', xChainId: '0x89.polygon' } // to token
+  );
+
+  // Check token allowance for bridge
+  const { data: hasAllowed } = useBridgeAllowance(bridgeParams, spokeProvider);
+  
+  // Approve tokens for bridge
+  const { approve: approveBridge, isLoading: isApproving } = useBridgeApprove(spokeProvider);
+  const handleApprove = async () => {
+    await approveBridge(bridgeParams);
+  };
+
+  // Execute bridge transaction
+  const { mutateAsync: bridge, isPending: isBridging } = useBridge(spokeProvider);
+  const handleBridge = async () => {
+    const result = await bridge({
+      srcChainId: '0x2105.base',
+      srcAsset: '0x...',
+      amount: 1000n,
+      dstChainId: '0x89.polygon',
+      dstAsset: '0x...',
+      recipient: '0x...'
+    });
+
+    console.log('Bridge transaction hashes:', {
+      spokeTxHash: result.value[0],
+      hubTxHash: result.value[1]
+    });
+  };
+}
 ```
 
 ## Requirements
@@ -210,19 +298,30 @@ function SwapComponent() {
 - [`useRepay()`](./src/hooks/mm/useRepay.ts) - Repay borrowed tokens
 - [`useSupply()`](./src/hooks/mm/useSupply.ts) - Supply tokens to the money market
 - [`useWithdraw()`](./src/hooks/mm/useWithdraw.ts) - Withdraw supplied tokens
-- [`useUserReservesData()`](./src/hooks/mm/useUserReservesData.ts) - Get list of supplied assets
-- [`useHubWalletAddress()`](./src/hooks/mm/useHubWalletAddress.ts) - Get hub wallet address for a spoke chain
+- [`useUserReservesData()`](./src/hooks/mm/useUserReservesData.ts) - Get user's reserves data(supplied asset and debt)
+- [`useReservesData()`](./src/hooks/mm/useReservesData.ts) - Get reserves data
+- [`useMMAllowance()`](./src/hooks/mm/useMMAllowance.ts) - Check token allowance for a specific amount
+- [`useMMApprove()`](./src/hooks/mm/useMMApprove.ts) - Approve token spending
 
 #### Swap Hooks
 - [`useQuote()`](./src/hooks/swap/useQuote.ts) - Get quote for an intent order
-- [`useCreateIntentOrder()`](./src/hooks/swap/useCreateIntentOrder.ts) - Create and submit an intent order
+- [`useSwap()`](./src/hooks/swap/useSwap.ts) - Create and submit an intent order
 - [`useStatus()`](./src/hooks/swap/useStatus.ts) - Get status of an intent order
+- [`useSwapAllowance()`](./src/hooks/swap/useSwapAllowance.ts) - Check token allowance for an intent order
+- [`useSwapApprove()`](./src/hooks/swap/useSwapApprove.ts) - Approve token spending
+- [`useCancelSwap()`](./src/hooks/swap/useCancelSwap.ts) - Cancel a swap intent order
 
 #### Shared Hooks
 - [`useSodaxContext()`](./src/hooks/shared/useSodaxContext.ts) - Access Sodax context and configuration
-- [`useAllowance()`](./src/hooks/shared/useAllowance.ts) - Check token allowance for a specific amount
-- [`useApprove()`](./src/hooks/shared/useApprove.ts) - Approve token spending
-
+- [`useEstimateGas()`](./src/hooks/shared/useEstimateGas.ts) - Estimate gas costs for transactions
+- [`useDeriveUserWalletAddress()`](./src/hooks/shared/useDeriveUserWalletAddress.ts) - Derive user wallet address for hub abstraction
+
+#### Bridge Hooks
+- [`useBridge()`](./src/hooks/bridge/useBridge.ts) - Execute bridge transactions to transfer tokens between chains
+- [`useBridgeAllowance()`](./src/hooks/bridge/useBridgeAllowance.ts) - Check token allowance for bridge operations
+- [`useBridgeApprove()`](./src/hooks/bridge/useBridgeApprove.ts) - Approve token spending for bridge actions
+- [`useGetBridgeableAmount()`](./src/hooks/bridge/useGetBridgeableAmount.ts) - Get maximum amount available to be bridged
+- [`useGetBridgeableTokens()`](./src/hooks/bridge/useGetBridgeableTokens.ts) - Get available destination tokens for bridging
 
 ## Contributing