@sodax/dapp-kit 0.0.1-rc.20 → 0.0.1-rc.22

package/README.md

@@ -32,6 +32,16 @@ dApp Kit is a collection of React components, hooks, and utilities designed to s
   - Get spoke chain provider (`useSpokeProvider`)
   - Get wallet provider (`useWalletProvider`)
 
+- 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`)
+
 ## Installation
 
 ```bash
@@ -148,6 +158,24 @@ 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, useSwap, useStatus } from '@sodax/dapp-kit';
 
@@ -178,6 +206,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
@@ -215,7 +290,14 @@ function SwapComponent() {
 #### Shared Hooks
 - [`useSodaxContext()`](./src/hooks/shared/useSodaxContext.ts) - Access Sodax context and configuration
 - [`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
 

package/dist/contexts/index.d.ts

@@ -1,9 +1,8 @@
-import type { EvmHubProvider, Sodax } from '@sodax/sdk';
+import type { Sodax } from '@sodax/sdk';
 import type { RpcConfig } from '@/types';
 export interface SodaxContextType {
     sodax: Sodax;
     testnet: boolean;
-    hubProvider: EvmHubProvider | undefined;
     rpcConfig: RpcConfig;
 }
 export declare const SodaxContext: import("react").Context<SodaxContextType | null>;

package/dist/contexts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,cAAc,GAAG,SAAS,CAAC;IACxC,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,kDAA+C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,kDAA+C,CAAC"}

package/dist/hooks/bridge/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useBridgeAllowance';
+export * from './useBridgeApprove';
+export * from './useBridge';
+export * from './useGetBridgeableAmount';
+export * from './useGetBridgeableTokens';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

package/dist/hooks/bridge/useBridge.d.ts

@@ -0,0 +1,33 @@
+import type { BridgeError, BridgeErrorCode, SpokeTxHash, HubTxHash, Result, CreateBridgeIntentParams } from '@sodax/sdk';
+import { type UseMutationResult } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+/**
+ * Hook for executing bridge transactions to transfer tokens between chains.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the bridge
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: bridge, isPending } = 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.spokeTxHash,
+ *     hubTxHash: result.hubTxHash
+ *   });
+ * };
+ * ```
+ */
+export declare function useBridge(spokeProvider: SpokeProvider | undefined): UseMutationResult<Result<[SpokeTxHash, HubTxHash], BridgeError<BridgeErrorCode>>, Error, CreateBridgeIntentParams>;
+//# sourceMappingURL=useBridge.d.ts.map

package/dist/hooks/bridge/useBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBridge.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useBridge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACzH,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CACvB,aAAa,EAAE,aAAa,GAAG,SAAS,GACvC,iBAAiB,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,wBAAwB,CAAC,CAqBpH"}

package/dist/hooks/bridge/useBridgeAllowance.d.ts

@@ -0,0 +1,23 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { SpokeProvider, CreateBridgeIntentParams } from '@sodax/sdk';
+/**
+ * Hook for checking token allowance for bridge operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific bridge action.
+ * It automatically queries and tracks the allowance status.
+ *
+ * @param {BridgeParams} params - The parameters for the bridge to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useBridgeAllowance(params, spokeProvider);
+ * ```
+ */
+export declare function useBridgeAllowance(params: CreateBridgeIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+//# sourceMappingURL=useBridgeAllowance.d.ts.map

package/dist/hooks/bridge/useBridgeAllowance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBridgeAllowance.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useBridgeAllowance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE1E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,aAAa,EAAE,aAAa,GAAG,SAAS,GACvC,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAsBhC"}

package/dist/hooks/bridge/useBridgeApprove.d.ts

@@ -0,0 +1,29 @@
+import type { CreateBridgeIntentParams, SpokeProvider } from '@sodax/sdk';
+interface UseBridgeApproveReturn {
+    approve: (params: CreateBridgeIntentParams) => Promise<boolean>;
+    isLoading: boolean;
+    error: Error | null;
+    resetError: () => void;
+}
+/**
+ * Hook for approving token spending for bridge actions
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useBridgeApprove(spokeProvider);
+ *
+ * // Approve tokens for bridge action
+ * await approve({
+ *   srcChainId: '0x2105.base',
+ *   srcAsset: '0x...',
+ *   amount: 1000n,
+ *   dstChainId: '0x89.polygon',
+ *   dstAsset: '0x...',
+ *   recipient: '0x...'
+ * });
+ * ```
+ */
+export declare function useBridgeApprove(spokeProvider: SpokeProvider | undefined): UseBridgeApproveReturn;
+export {};
+//# sourceMappingURL=useBridgeApprove.d.ts.map

package/dist/hooks/bridge/useBridgeApprove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBridgeApprove.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useBridgeApprove.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG1E,UAAU,sBAAsB;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,wBAAwB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAChE,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,GAAG,sBAAsB,CAqCjG"}

package/dist/hooks/bridge/useGetBridgeableAmount.d.ts

@@ -0,0 +1,26 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { XToken } from '@sodax/sdk';
+/**
+ * Hook for getting the amount available to be bridged.
+ *
+ * This hook is used to check if a target chain has enough balance to bridge when bridging.
+ * It automatically queries and tracks the available amount to be bridged.
+ *
+ * @param {SpokeChainId | undefined} chainId - The chain ID to get the balance for
+ * @param {string | undefined} token - The token address to get the balance for
+ *
+ * @returns {UseQueryResult<bigint, Error>} A React Query result containing:
+ *   - data: The available amount to be bridged (bigint)
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: balance, isLoading } = useSpokeAssetManagerTokenBalance(chainId, tokenAddress);
+ *
+ * if (balance) {
+ *   console.log('Asset manager token balance:', balance.toString());
+ * }
+ * ```
+ */
+export declare function useGetBridgeableAmount(from: XToken | undefined, to: XToken | undefined): UseQueryResult<bigint, Error>;
+//# sourceMappingURL=useGetBridgeableAmount.d.ts.map

package/dist/hooks/bridge/useGetBridgeableAmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGetBridgeableAmount.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useGetBridgeableAmount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAwB,MAAM,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,EAAE,EAAE,MAAM,GAAG,SAAS,GACrB,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAoB/B"}

package/dist/hooks/bridge/useGetBridgeableTokens.d.ts

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import { type XToken, type SpokeChainId } from '@sodax/sdk';
+/**
+/**
+ * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.
+ *
+ * This hook queries and tracks the set of tokens on the destination chain that can be bridged to,
+ * given a source chain, destination chain, and source token address.
+ *
+ * @param {SpokeChainId | undefined} from - The source chain ID
+ * @param {SpokeChainId | undefined} to - The destination chain ID
+ * @param {string | undefined} token - The source token address
+ *
+ * @returns {UseQueryResult<XToken[], Error>} A React Query result containing:
+ *   - data: Array of bridgeable tokens (XToken[]) on the destination chain
+ *   - error: Any error that occurred during the query
+ *
+ *
+ * @example
+ * ```typescript
+ * const { data: bridgeableTokens, isLoading } = useGetBridgeableTokens(
+ *   fromChainId,
+ *   toChainId,
+ *   fromTokenAddress
+ * );
+ *
+ * if (bridgeableTokens && bridgeableTokens.length > 0) {
+ *   bridgeableTokens.forEach(token => {
+ *     console.log(`Bridgeable token: ${token.symbol} (${token.address}) on chain ${token.xChainId}`);
+ *   });
+ * } else {
+ *   console.log('No bridgeable tokens found for the selected route.');
+ * }
+ * ```
+ */
+export declare function useGetBridgeableTokens(from: SpokeChainId | undefined, to: SpokeChainId | undefined, token: string | undefined): UseQueryResult<XToken[], Error>;
+//# sourceMappingURL=useGetBridgeableTokens.d.ts.map

package/dist/hooks/bridge/useGetBridgeableTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGetBridgeableTokens.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useGetBridgeableTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,EAAE,EAAE,YAAY,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,cAAc,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,CAoBjC"}

package/dist/hooks/index.d.ts

@@ -2,4 +2,5 @@ export * from './shared';
 export * from './provider';
 export * from './mm';
 export * from './swap';
+export * from './bridge';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/hooks/mm/useUserFormattedSummary.d.ts

@@ -1,4 +1,4 @@
-import { type FormatUserSummaryResponse, type FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
+import type { FormatUserSummaryResponse, FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
 import { type UseQueryResult } from '@tanstack/react-query';
 /**
  * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,

package/dist/hooks/mm/useUserFormattedSummary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUserFormattedSummary.d.ts","sourceRoot":"","sources":["../../../src/hooks/mm/useUserFormattedSummary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yBAAyB,EAAE,KAAK,wBAAwB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC1G,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGtE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,cAAc,CAAC,yBAAyB,CAAC,wBAAwB,CAAC,EAAE,KAAK,CAAC,CA6B5E"}
+{"version":3,"file":"useUserFormattedSummary.d.ts","sourceRoot":"","sources":["../../../src/hooks/mm/useUserFormattedSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACrG,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGtE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,cAAc,CAAC,yBAAyB,CAAC,wBAAwB,CAAC,EAAE,KAAK,CAAC,CA6B5E"}

package/dist/hooks/mm/useUserReservesData.d.ts

@@ -1,4 +1,4 @@
-import { SpokeProvider, type UserReserveData } from '@sodax/sdk';
+import type { SpokeProvider, UserReserveData } from '@sodax/sdk';
 import { type UseQueryResult } from '@tanstack/react-query';
 /**
  * Hook for fetching user reserves data from the Sodax money market.

package/dist/hooks/mm/useUserReservesData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUserReservesData.d.ts","sourceRoot":"","sources":["../../../src/hooks/mm/useUserReservesData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,eAAe,SAAO,GACrB,cAAc,CAAC,SAAS,CAAC,SAAS,eAAe,EAAE,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAetE"}
+{"version":3,"file":"useUserReservesData.d.ts","sourceRoot":"","sources":["../../../src/hooks/mm/useUserReservesData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,eAAe,SAAO,GACrB,cAAc,CAAC,SAAS,CAAC,SAAS,eAAe,EAAE,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAetE"}

package/dist/hooks/provider/useHubProvider.d.ts

@@ -1,3 +1,3 @@
 import type { EvmHubProvider } from '@sodax/sdk';
-export declare function useHubProvider(): EvmHubProvider | undefined;
+export declare function useHubProvider(): EvmHubProvider;
 //# sourceMappingURL=useHubProvider.d.ts.map

package/dist/hooks/provider/useHubProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHubProvider.d.ts","sourceRoot":"","sources":["../../../src/hooks/provider/useHubProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,wBAAgB,cAAc,IAAI,cAAc,GAAG,SAAS,CAI3D"}
+{"version":3,"file":"useHubProvider.d.ts","sourceRoot":"","sources":["../../../src/hooks/provider/useHubProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,wBAAgB,cAAc,IAAI,cAAc,CAI/C"}

package/dist/hooks/provider/useSpokeProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSpokeProvider.d.ts","sourceRoot":"","sources":["../../../src/hooks/provider/useSpokeProvider.ts"],"names":[],"mappings":"AACA,OAAO,EAYL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMrB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAIV,YAAY,EAIb,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,cAAc,CAAC,EAAE,eAAe,GAAG,SAAS,GAC3C,aAAa,GAAG,SAAS,CAoE3B"}
+{"version":3,"file":"useSpokeProvider.d.ts","sourceRoot":"","sources":["../../../src/hooks/provider/useSpokeProvider.ts"],"names":[],"mappings":"AACA,OAAO,EAYL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMrB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAIV,YAAY,EAIb,MAAM,cAAc,CAAC;AAGtB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,cAAc,CAAC,EAAE,eAAe,GAAG,SAAS,GAC3C,aAAa,GAAG,SAAS,CA0E3B"}

package/dist/hooks/shared/index.d.ts

@@ -1,3 +1,4 @@
 export * from './useSodaxContext';
 export * from './useEstimateGas';
+export * from './useDeriveUserWalletAddress';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/shared/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,8BAA8B,CAAC"}

package/dist/hooks/shared/useDeriveUserWalletAddress.d.ts

@@ -0,0 +1,24 @@
+import { type SpokeProvider } from '@sodax/sdk';
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { Address } from 'viem';
+/**
+ * Hook for deriving user wallet address for hub abstraction.
+ *
+ * This hook derives the user's abstracted wallet address for the hub chain.
+ * If the spoke chain is the same as the hub chain, it returns the original wallet address.
+ * Otherwise, it returns the abstracted wallet address for cross-chain operations.
+ *
+ * @param spokeProvider - The spoke provider instance for the origin chain
+ * @param walletAddress - Optional user wallet address on spoke chain. If not provided, will fetch from spokeProvider
+ * @returns A React Query result object containing:
+ *   - data: The derived user wallet address when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during derivation
+ *
+ * @example
+ * ```typescript
+ * const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeProvider, userAddress);
+ * ```
+ */
+export declare function useDeriveUserWalletAddress(spokeProvider: SpokeProvider | undefined, walletAddress?: string | undefined): UseQueryResult<Address, Error>;
+//# sourceMappingURL=useDeriveUserWalletAddress.d.ts.map

package/dist/hooks/shared/useDeriveUserWalletAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeriveUserWalletAddress.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/useDeriveUserWalletAddress.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,aAAa,EAAuB,MAAM,YAAY,CAAC;AAC9F,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAehC"}

package/dist/index.js

@@ -29,11 +29,26 @@ function useEstimateGas(spokeProvider) {
     }
   });
 }
+function useDeriveUserWalletAddress(spokeProvider, walletAddress) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["deriveUserWalletAddress", spokeProvider?.chainConfig.chain.id, walletAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      return await sdk.deriveUserWalletAddress(spokeProvider, sodax.hubProvider, walletAddress);
+    },
+    enabled: !!spokeProvider,
+    refetchInterval: false
+    // This is a deterministic operation, no need to refetch
+  });
+}
 
 // src/hooks/provider/useHubProvider.ts
 function useHubProvider() {
-  const { hubProvider } = useSodaxContext();
-  return hubProvider;
+  const { sodax } = useSodaxContext();
+  return sodax.hubProvider;
 }
 function useSpokeProvider(spokeChainId, walletProvider) {
   const { rpcConfig } = useSodaxContext();
@@ -75,10 +90,14 @@ function useSpokeProvider(spokeChainId, walletProvider) {
     }
     if (xChainType === "STELLAR") {
       const stellarConfig = sdk.spokeChainConfig[spokeChainId];
-      return new sdk.StellarSpokeProvider(walletProvider, stellarConfig, {
-        horizonRpcUrl: stellarConfig.horizonRpcUrl,
-        sorobanRpcUrl: stellarConfig.sorobanRpcUrl
-      });
+      return new sdk.StellarSpokeProvider(
+        walletProvider,
+        stellarConfig,
+        rpcConfig.stellar ? rpcConfig.stellar : {
+          horizonRpcUrl: stellarConfig.horizonRpcUrl,
+          sorobanRpcUrl: stellarConfig.sorobanRpcUrl
+        }
+      );
     }
     if (xChainType === "SOLANA") {
       return new sdk.SolanaSpokeProvider(
@@ -374,21 +393,116 @@ function useCancelSwap(spokeProvider) {
     }
   });
 }
-var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
-  const sodax = new sdk.Sodax(config);
-  const hubChainId = config?.hubProviderConfig?.chainConfig.chain.id;
-  const hubRpcUrl = config?.hubProviderConfig?.hubRpcUrl;
-  const hubProvider = React.useMemo(() => {
-    if (hubChainId && hubRpcUrl) {
-      const hubChainCfg = sdk.getHubChainConfig(hubChainId);
-      return new sdk.EvmHubProvider({
-        hubRpcUrl,
-        chainConfig: hubChainCfg
+function useBridgeAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["bridge-allowance", params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.bridge.isAllowanceValid({
+        params,
+        spokeProvider
+      });
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params
+  });
+}
+function useBridgeApprove(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError
+  } = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const allowance = await sodax.bridge.approve({
+        params,
+        spokeProvider
       });
+      if (!allowance.ok) {
+        throw new Error("Failed to approve tokens for bridge");
+      }
+      return true;
+    },
+    onSuccess: (_, params) => {
+      queryClient.invalidateQueries({ queryKey: ["bridge-allowance", params] });
     }
-    return void 0;
-  }, [hubChainId, hubRpcUrl]);
-  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, hubProvider, rpcConfig } }, children);
+  });
+  return {
+    approve,
+    isLoading: isPending,
+    error,
+    resetError
+  };
+}
+function useBridge(spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      const result = await sodax.bridge.bridge({
+        params,
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Bridge failed: ${result.error.code}`);
+      }
+      return result;
+    }
+  });
+}
+function useGetBridgeableAmount(from, to) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["spoke-asset-manager-token-balance", from, to],
+    queryFn: async () => {
+      if (!from || !to) {
+        return 0n;
+      }
+      const result = await sodax.bridge.getBridgeableAmount(from, to);
+      if (result.ok) {
+        return result.value;
+      }
+      console.error("Error getting bridgeable amount:", result.error);
+      return 0n;
+    },
+    enabled: !!from && !!to
+  });
+}
+function useGetBridgeableTokens(from, to, token) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["bridgeable-tokens", from, to, token],
+    queryFn: async () => {
+      if (!from || !to || !token) {
+        return [];
+      }
+      const result = sodax.bridge.getBridgeableTokens(from, to, token);
+      if (result.ok) {
+        return result.value;
+      }
+      console.error("Error getting bridgeable tokens:", result.error);
+      return [];
+    },
+    enabled: !!from && !!to && !!token
+  });
+}
+var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
+  const sodax = new sdk.Sodax(config);
+  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
 };
 var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
   const tokens = sdk.hubAssets[spokeChainId];
@@ -401,8 +515,14 @@ var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
 exports.SodaxProvider = SodaxProvider;
 exports.getSpokeTokenAddressByVault = getSpokeTokenAddressByVault;
 exports.useBorrow = useBorrow;
+exports.useBridge = useBridge;
+exports.useBridgeAllowance = useBridgeAllowance;
+exports.useBridgeApprove = useBridgeApprove;
 exports.useCancelSwap = useCancelSwap;
+exports.useDeriveUserWalletAddress = useDeriveUserWalletAddress;
 exports.useEstimateGas = useEstimateGas;
+exports.useGetBridgeableAmount = useGetBridgeableAmount;
+exports.useGetBridgeableTokens = useGetBridgeableTokens;
 exports.useHubProvider = useHubProvider;
 exports.useMMAllowance = useMMAllowance;
 exports.useMMApprove = useMMApprove;