@spicenet-io/spiceflow-ui 4.9.4 → 4.9.6-consistency.0

package/dist/execution/pollIntentStep.d.ts

@@ -18,12 +18,14 @@ type PollIntentStepOptions = {
 };
 export declare function pollIntentStepUntilSuccess(options: PollIntentStepOptions): Promise<string | undefined>;
 export declare function runAllIntentSteps(options: {
+    resume?: boolean;
     actionId: string;
     intentIndex: number;
     intentId: string;
     totalSteps: number;
     delayBeforeSpicenetStepMs?: number;
     isSpicenetStep?: (stepIndex: number) => boolean;
+    beforeStep?: (stepIndex: number) => Promise<void>;
     maxExecuteAttemptsForStep?: (stepIndex: number) => number;
     maxPolls?: number;
     onStatusMessage?: (message: string, txHash?: string) => void;

package/dist/execution/sourceFunding.d.ts

@@ -0,0 +1,29 @@
+import { type Address } from "viem";
+import type { TransactionObserver } from "./externalWalletClient";
+export interface SourceFundingState {
+    version: 1;
+    identity: string;
+    baseline: string;
+    confirmedAmount: string;
+    pending?: {
+        amount: string;
+        hash?: `0x${string}`;
+    };
+}
+export declare function isSourceFundingState(value: unknown): value is SourceFundingState;
+export declare function fundSelectedExternalSource(params: {
+    identity: string;
+    state?: SourceFundingState;
+    onState: (state: SourceFundingState) => void;
+    createWallet: () => Promise<{
+        extWc: any;
+        viemChain?: any;
+    }>;
+    sourceClient: any;
+    recipient: Address;
+    tokenAddr: Address;
+    isNative: boolean;
+    requiredAmount: bigint;
+    reconcileOnly?: boolean;
+    observer?: TransactionObserver;
+}): Promise<void>;

package/dist/execution/transactionReceipt.d.ts

@@ -0,0 +1,12 @@
+import type { Call } from "../types/authorization";
+export declare function confirmDestinationReceipt(client: any, hash: string | undefined): Promise<string>;
+export declare function waitForExpectedTransactionReceipt(params: {
+    client: any;
+    hash: `0x${string}`;
+    call: Call;
+    onRepriced?: (hash: `0x${string}`) => void;
+    onCancelled?: () => void;
+}): Promise<{
+    receipt: any;
+    hash: `0x${string}`;
+}>;

package/dist/hooks/index.d.ts

@@ -1,12 +1,12 @@
-export { useWalletBalances, fetchBalances } from "./useWalletBalances";
+export { fetchBalances, useWalletBalances } from "./useWalletBalances";
 export { useAssetInput } from "./useAssetInput";
 export type { UseAssetInputReturn } from "./useAssetInput";
 export { useWallet } from "./useWallet";
-export type { UseWalletReturn, WalletState, WalletActions } from "./useWallet";
+export type { UseWalletReturn, WalletActions, WalletState } from "./useWallet";
 export { useSpiceAssets } from "./useSpiceAssets";
 export type { UseSpiceAssetsConfig, UseSpiceAssetsReturn, } from "./useSpiceAssets";
 export { useSpiceExecution } from "./useSpiceExecution";
-export type { ExecutionProgress, ExecutionStep, ExecutionOptions, OnProgress, } from "./useSpiceExecution";
+export type { ExecutionOptions, ExecutionProgress, ExecutionStep, OnProgress, } from "./useSpiceExecution";
 export { useLockDuration } from "./useLockDuration";
 export type { UseLockDurationReturn } from "./useLockDuration";
 export type { VerifiedPendingDeposit } from "./usePendingDeposit";
@@ -16,6 +16,9 @@ export { useSpiceBrand } from "./useSpiceBrand";
 export { useSmartWallet } from "./useSmartWallet";
 export { useIsUserWhitelisted } from "./useIsUserWhitelisted";
 export type { PartnerWhitelistCheckResponse, UseIsUserWhitelistedOptions, } from "./useIsUserWhitelisted";
-export { useSupplyAssets, isSupportedSupplyAsset } from "./useSupplyAssets";
-export { useSupplyQuote, resolveInputSupplySwapQuote } from "./useSupplyQuote";
-export type { UseSupplyQuoteOpts, SupplyQuoteResult } from "./useSupplyQuote";
+export { isSupportedSupplyAsset, useSupplyAssets } from "./useSupplyAssets";
+export { resolveInputSupplySwapQuote, useSupplyQuote } from "./useSupplyQuote";
+export type { SupplyQuoteResult, UseSupplyQuoteOpts } from "./useSupplyQuote";
+export { useSpiceInventory } from "./useSpiceInventory";
+export { useSpiceLock, type UseSpiceLockParams } from "./useSpiceLock";
+export { useSpiceSupply, type UseSpiceSupplyParams, type UseSpiceSupplyResult, } from "./useSpiceSupply";

package/dist/hooks/useDestinationToken.d.ts

@@ -0,0 +1,20 @@
+import { type Address } from "viem";
+export declare function useDestinationToken(params: {
+    enabled: boolean;
+    chainId: number;
+    address?: Address;
+    decimals?: number;
+    symbol: string;
+    logoURI?: string;
+}): {
+    token: {
+        address: `0x${string}`;
+        chainId: number;
+        decimals: number;
+        symbol: string;
+        logoURI: string | undefined;
+    };
+    error: string | null;
+    ready: boolean;
+    refresh: () => void;
+};

package/dist/hooks/useInventoryResource.d.ts

@@ -0,0 +1,21 @@
+import { type InventoryRead, type InventoryStore } from "../utils/inventoryStore";
+export declare function useInventoryStore(): {
+    entry(key: string): {
+        snapshot: () => import("../utils/inventoryStore").InventorySnapshot;
+        refresh: () => Promise<void>;
+        invalidate: () => Promise<void>;
+        subscribe(notify: () => void, fetch: () => Promise<InventoryRead>, interval: number): () => void;
+    };
+    fetcherId(fetcher: Function): number;
+    registerTokens(additional: import("../utils/inventoryStore").InventoryToken[]): void;
+    tokens: () => import("../utils/inventoryStore").InventoryToken[];
+    invalidate: () => Promise<void>;
+};
+export declare function useInventoryResource(key: string, read: () => Promise<InventoryRead>, enabled: boolean, interval: number, providedStore?: InventoryStore): {
+    refresh: () => Promise<void>;
+    assets: import("..").Asset[];
+    loading: boolean;
+    refreshing: boolean;
+    error: string | null;
+    updatedAt: number | null;
+};

package/dist/hooks/useLockWalletAssets.d.ts

@@ -1,4 +1,4 @@
-import { type Address } from "viem";
+import type { Address } from "viem";
 import type { Asset } from "../types/assets";
 export declare function useLockWalletAssets(params: {
     isOpen: boolean;

package/dist/hooks/usePendingAction.d.ts

@@ -0,0 +1,7 @@
+import type { SelectedAsset } from "../types/assets";
+import { type PendingDepositRecord } from "../utils/pendingDeposit";
+export declare function usePendingAction(embedded: string | null | undefined, purpose: string): {
+    record: PendingDepositRecord | undefined;
+    selection: SelectedAsset | undefined;
+    error: string | undefined;
+};

package/dist/hooks/useSpiceAction.d.ts

@@ -0,0 +1,46 @@
+import { type Address } from "viem";
+import type { Asset, SelectedAsset } from "../types/assets";
+import type { DestinationTokenConfig, SpiceSupplyProps } from "../types/supply";
+export type SpiceActionSource = Asset;
+export interface UseSpiceActionOptions {
+    destinationToken: DestinationTokenConfig;
+    recipient?: Address;
+    buildActionCalls: SpiceSupplyProps["buildActionCalls"];
+    buildSpicenetBatch?: SpiceSupplyProps["buildSpicenetBatch"];
+    amount: string;
+    sourceChains?: number[];
+    supportedSourceAssets?: string[];
+    feeExecutionMode?: SpiceSupplyProps["feeExecutionMode"];
+    enabled?: boolean;
+    onSuccess?: SpiceSupplyProps["onSuccess"];
+    onError?: SpiceSupplyProps["onError"];
+}
+export declare function useSpiceAction({ amount, enabled, ...options }: UseSpiceActionOptions): {
+    sources: Asset[];
+    selectedAsset: SelectedAsset | null;
+    setSelectedAsset: import("react").Dispatch<import("react").SetStateAction<SelectedAsset | null>>;
+    selectAsset: (asset: Asset) => void;
+    quote: {
+        isQuoting: boolean;
+        error: string | null;
+        estimatedInput: string | null;
+        estimatedOutput: string | null;
+        estimatedMinOutput: string | null;
+        isDirect: boolean;
+        needsSwap: boolean;
+    };
+    feePreview: import("../types").FeePreview | null;
+    isFeePreviewLoading: boolean;
+    feePreviewError: string | null;
+    canSubmit: boolean;
+    execute: () => Promise<void>;
+    isExecuting: boolean;
+    step: import("..").SupplyStep;
+    statusMsg: string;
+    txHash: string | null;
+    refreshAssets: () => Promise<void>;
+    resolveMaxAmount: (asset: Asset) => Promise<string | null>;
+    retryFinalization: () => void;
+};
+export type UseSpiceActionResult = ReturnType<typeof useSpiceAction>;
+export type SpiceActionQuote = UseSpiceActionResult["quote"];

package/dist/hooks/useSpiceAssets.d.ts

@@ -10,6 +10,8 @@ export interface UseSpiceAssetsConfig {
 export interface UseSpiceAssetsReturn {
     assets: Asset[];
     loading: boolean;
+    refreshing?: boolean;
+    updatedAt?: number | null;
     error: string | null;
     hasBalance: boolean;
     refetch: () => Promise<void>;

package/dist/hooks/useSpiceExecution.d.ts

@@ -1,6 +1,6 @@
-import { Address } from "viem";
-import { ChainBatch, Call } from "../types/authorization";
 import type { FeeEstimateSummary } from "@spicenet-io/spiceflow-core";
+import { Address } from "viem";
+import { Call, ChainBatch } from "../types/authorization";
 import { type ActionOutputCredit } from "../utils/actionOutputEscrowFunding";
 export type { Call, ChainBatch };
 export type ExecutionStep = "idle" | "building" | "signing-delegation" | "signing-intent" | "submitting" | "executing" | "confirming-rollup" | "success" | "error";
@@ -16,6 +16,12 @@ export interface ExecutionProgress {
 }
 export type OnProgress = (progress: ExecutionProgress) => void;
 export interface ExecutionOptions {
+    requireDestinationReceipt?: boolean;
+    prepareForSigning?: (chainBatches: ChainBatch[]) => Promise<ChainBatch[]>;
+    resolveActionOutputCredits?: () => Promise<ActionOutputCredit[]>;
+    validateBeforeSubmit?: (batches: ChainBatch[]) => void | Promise<void>;
+    beforeActionSubmit?: () => void | Promise<void>;
+    onActionCreated?: (intentId: string, stepCount: number, recovery: NonNullable<import("../utils/pendingDeposit").PendingDepositRecord["actionFunding"]>["recovery"]) => void;
     depositToEscrow?: {
         token: Address;
         amount: bigint;

package/dist/hooks/useSpiceInventory.d.ts

@@ -0,0 +1,31 @@
+import type { Address } from "viem";
+import type { Asset } from "../types/assets";
+import type { DestinationTokenConfig } from "../types/supply";
+import { type AssetRole } from "../utils/assetPolicy";
+import type { InventoryToken } from "../utils/inventoryStore";
+export declare function useSpiceInventory(options: {
+    enabled?: boolean;
+    owner?: Address;
+    role?: AssetRole;
+    destination?: DestinationTokenConfig;
+    sourceChains?: number[];
+    supportedSourceAssets?: string[];
+    additionalSourceTokens?: InventoryToken[];
+    includeWalletAssets?: boolean;
+    includeRollupAssets?: boolean;
+    requiresEscrow?: boolean;
+}): {
+    positions: {
+        eligible: boolean;
+        reason: string | null;
+        policyExcluded?: boolean;
+        asset: Asset;
+    }[];
+    assets: Asset[];
+    walletAssets: Asset[];
+    rollupAssets: Asset[];
+    loading: boolean;
+    refreshing: boolean | undefined;
+    error: string | null;
+    refresh: () => Promise<void>;
+};

package/dist/hooks/useSpiceLock.d.ts

@@ -0,0 +1,129 @@
+import type { Asset, SelectedAsset } from "../types/assets";
+import type { SpiceLockModalProps } from "../types/lock";
+export interface UseSpiceLockParams extends Pick<SpiceLockModalProps, "lockBatches" | "lockChainId" | "lockTokenSymbol" | "lockTokenLogoURI" | "destinationTokenAddress" | "destinationTokenDecimals" | "beneficiary" | "onLockSuccess" | "onLockError" | "buildSpicenetBatch"> {
+    enabled: boolean;
+    selectedAsset: SelectedAsset | null;
+    recoveryKey?: string;
+}
+export declare function useSpiceLock(params: UseSpiceLockParams): {
+    quote: {
+        refreshQuote: () => void;
+        resolvedSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+        inputAmount?: bigint | null;
+        estimatedOutput: string | null;
+        hasSourceConversion: boolean;
+        executionInput: {
+            address: `0x${string}`;
+            chainId: number;
+            decimals: number;
+            amount: bigint;
+        } | null;
+        inputDecimals?: number | null;
+        quoteKey: string | null;
+        quoteExpiresAt: number | null;
+        isQuoting: boolean;
+        quoteError: string | null;
+        estimatedInput: string | null;
+        exactOutputSwap: import("..").ResolvedExactOutputSwap | null;
+        quoteAmountOut: bigint | null;
+        resolvedTokenIn: import("viem").Address | null;
+        isDirect: boolean;
+        needsSwap: boolean;
+        selectedIsEquivalent: boolean;
+        sourceSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+        sourceExactOutputSwap: import("..").ResolvedExactOutputSwap | null;
+        pivot: import("../types/supply").PivotRoute | null;
+    };
+    destination: {
+        address: `0x${string}`;
+        chainId: number;
+        decimals: number;
+        symbol: string;
+        logoURI: string | undefined;
+    };
+    metadataError: string | null;
+    canExecute: boolean;
+    selectedAsset: SelectedAsset | null;
+    capability: {
+        eligible: boolean;
+        reason: string | null;
+        policyExcluded?: boolean;
+    } | null;
+    assets: {
+        selectable: Asset[];
+        displayAssets: Asset[];
+        filteredSpiceAssets: Asset[];
+        embeddedWalletAddress: `0x${string}` | undefined;
+        externalAddress: `0x${string}` | undefined;
+        isNon7702: boolean;
+        refreshSpiceAssets: () => Promise<void>;
+        refreshWalletAssets: () => Promise<void>;
+        loading: boolean;
+        refreshing: boolean | undefined;
+        error: string | null;
+    };
+    fees: {
+        fundingConversion: import("../components/SpiceSupply/lib/feeConversion").FundingConversion | undefined;
+        proceedsUsed: bigint | undefined;
+        fundingShortfall: bigint | undefined;
+        source: {
+            address: `0x${string}`;
+            chainId: number;
+            symbol: string;
+            decimals: number;
+            gasFee: bigint;
+            spicenetFee: bigint;
+        } | null;
+        destinationAmount: bigint | undefined;
+        sourceSpendCap: bigint | undefined;
+        preview: import("../types").FeePreview | null;
+        isLoading: boolean;
+        ready: boolean;
+        error: string | null;
+    };
+    amount: {
+        sourceRequiredAmount: bigint | null;
+        parsed: number;
+        isInsufficientBalance: boolean;
+        sourceBalance: number;
+        feesExceedAmount: boolean;
+    };
+    status: {
+        sourceFunding: {
+            matchesPurpose: boolean;
+            matchesSelection: boolean;
+            phase: "complete" | "routing" | "funding";
+            amount: string;
+        } | null;
+        finalizing: boolean;
+        finalizationError: string | null;
+        externalAction: {
+            destinationToken: import("viem").Address;
+            destinationDecimals: number;
+            amount?: string;
+            phase: "funding" | "routing" | "action" | "complete";
+            confirmedCalls: number;
+            totalCalls: number;
+            requiresRecovery: boolean;
+        } | null;
+        step: import("..").SupplyStep;
+        statusMsg: string;
+        txHash: string | null;
+        isExecuting: boolean;
+        error: string | null;
+        showStatusPanel: boolean;
+        paymentResult: import("..").PaymentResult | null;
+    };
+    flags: {
+        directExecutionFeeNote: boolean;
+    };
+    retryFinalization: () => void;
+    fundEmbeddedSource: (amount: bigint) => Promise<void>;
+    submitSupply: () => Promise<void>;
+    submitPay: () => Promise<void>;
+    retrySupply: () => void;
+    dismissPaymentStatus: () => void;
+    resolveMaxAmount: (asset: Asset) => Promise<string | null>;
+    resetAfterSuccess: () => void;
+    resetPaymentState: () => void;
+};

package/dist/hooks/useSpiceLockQuote.d.ts

@@ -1,4 +1,4 @@
-import { type Address } from "viem";
+import type { Address } from "viem";
 import type { Asset, SelectedAsset } from "../types/assets";
 export declare function useSpiceLockQuote(params: {
     enabled: boolean;
@@ -10,7 +10,38 @@ export declare function useSpiceLockQuote(params: {
     recipient?: Address;
 }): {
     conversion: {
-        input: Asset;
+        input: {
+            address: `0x${string}`;
+            decimals: number;
+            isNative: boolean;
+            _fundingWallet?: "external" | "embedded";
+            owner?: Address;
+            location?: "external" | "embedded" | "rollup";
+            positionId?: string;
+            _source?: "wallet" | "spice";
+            symbol: string;
+            name: string;
+            chainId: number;
+            balance: bigint;
+            balanceError?: string;
+            balanceStatus?: "stale";
+            _wrapFromNative?: boolean;
+            balanceFormatted: number;
+            balanceUsd: number;
+            priceStatus?: "fresh" | "stale" | "unavailable";
+            logoURI?: string;
+            displaySymbol?: string;
+            displayName?: string;
+            displayChainName?: string;
+            receiptTokenId?: string;
+            receiptTokenName?: string;
+            receiptTokenDecimals?: number;
+            chainTokens?: Record<string, {
+                name?: string;
+                decimals?: number;
+            }>;
+            isUniversal?: boolean;
+        };
         amountIn: bigint;
         output: Asset;
         minimum: bigint;
@@ -18,7 +49,7 @@ export declare function useSpiceLockQuote(params: {
         key: string;
         expiresAt: number | null;
     } | null;
-    error: string | null;
     retryQuote: () => void;
+    error: string | null;
     isQuoting: boolean;
 };

package/dist/hooks/useSpiceRollupPrices.d.ts

@@ -1,2 +1,9 @@
 import type { Asset } from "../types/assets";
+type PriceConfig = {
+    supportedChains?: number[];
+    nativeChainId?: number;
+    rpcOverrides?: Record<number, string>;
+};
+export declare function priceRollupAssets(assets: Asset[], config: PriceConfig): Promise<Asset[]>;
 export declare function useSpiceRollupPrices(assets: Asset[], enabled: boolean, supportedChains?: number[]): Asset[];
+export {};

package/dist/hooks/useSpiceSupply.d.ts

@@ -0,0 +1,133 @@
+import { type Address } from "viem";
+import { type PaymentResult, type SupplyStep } from "../components/SpiceSupply/lib/executors";
+import type { Asset, SelectedAsset } from "../types/assets";
+import type { SpiceSupplyProps } from "../types/supply";
+import type { FeePreview } from "../types/ui";
+export interface UseSpiceSupplyParams extends Pick<SpiceSupplyProps, "destinationToken" | "sourceChains" | "supportedSourceAssets" | "buildActionCalls" | "feeExecutionMode" | "buildSpicenetBatch" | "onPayExecute" | "resolveExactOutputSwap" | "amountDirection" | "onSuccess" | "onError" | "additionalSourceTokens" | "includeExternalWalletAssets" | "includeCrossChainEmbeddedAssets" | "sourceFundingRecovery" | "feeOnlyAction" | "actionProceeds" | "maxSlippage" | "resolveInputSwap"> {
+    enabled: boolean;
+    selectedAsset: SelectedAsset | null;
+    paymentAmount?: string;
+    recipient?: Address;
+    isZeroAmountPay?: boolean;
+    sourceFundingRecoveryKey?: string;
+    actionExecution?: {
+        wallet: "external";
+        recoveryKey: string;
+    };
+    prependSourceEscrow?: boolean;
+}
+export declare function useSpiceSupply(params: UseSpiceSupplyParams): {
+    selectedAsset: SelectedAsset | null;
+    capability: {
+        eligible: boolean;
+        reason: string | null;
+        policyExcluded?: boolean;
+    } | null;
+    assets: {
+        selectable: Asset[];
+        displayAssets: Asset[];
+        filteredSpiceAssets: Asset[];
+        embeddedWalletAddress: `0x${string}` | undefined;
+        externalAddress: `0x${string}` | undefined;
+        isNon7702: boolean;
+        refreshSpiceAssets: () => Promise<void>;
+        refreshWalletAssets: () => Promise<void>;
+        loading: boolean;
+        refreshing: boolean | undefined;
+        error: string | null;
+    };
+    quote: {
+        resolvedSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+        inputAmount?: bigint | null;
+        estimatedOutput: string | null;
+        hasSourceConversion: boolean;
+        executionInput: {
+            address: `0x${string}`;
+            chainId: number;
+            decimals: number;
+            amount: bigint;
+        } | null;
+        inputDecimals?: number | null;
+        quoteKey: string | null;
+        quoteExpiresAt: number | null;
+        refreshQuote: () => void;
+        isQuoting: boolean;
+        quoteError: string | null;
+        estimatedInput: string | null;
+        exactOutputSwap: import("..").ResolvedExactOutputSwap | null;
+        quoteAmountOut: bigint | null;
+        resolvedTokenIn: Address | null;
+        isDirect: boolean;
+        needsSwap: boolean;
+        selectedIsEquivalent: boolean;
+        sourceSwap: import("@spicenet-io/spiceflow-core").ResolvedSwap | null;
+        sourceExactOutputSwap: import("..").ResolvedExactOutputSwap | null;
+        pivot: import("../types/supply").PivotRoute | null;
+    };
+    fees: {
+        fundingConversion: import("../components/SpiceSupply/lib/feeConversion").FundingConversion | undefined;
+        proceedsUsed: bigint | undefined;
+        fundingShortfall: bigint | undefined;
+        source: {
+            address: `0x${string}`;
+            chainId: number;
+            symbol: string;
+            decimals: number;
+            gasFee: bigint;
+            spicenetFee: bigint;
+        } | null;
+        destinationAmount: bigint | undefined;
+        sourceSpendCap: bigint | undefined;
+        preview: FeePreview | null;
+        isLoading: boolean;
+        ready: boolean;
+        error: string | null;
+    };
+    amount: {
+        sourceRequiredAmount: bigint | null;
+        parsed: number;
+        isInsufficientBalance: boolean;
+        sourceBalance: number;
+        feesExceedAmount: boolean;
+    };
+    status: {
+        sourceFunding: {
+            matchesPurpose: boolean;
+            matchesSelection: boolean;
+            phase: "complete" | "routing" | "funding";
+            amount: string;
+        } | null;
+        finalizing: boolean;
+        finalizationError: string | null;
+        externalAction: {
+            destinationToken: Address;
+            destinationDecimals: number;
+            amount?: string;
+            phase: "funding" | "routing" | "action" | "complete";
+            confirmedCalls: number;
+            totalCalls: number;
+            requiresRecovery: boolean;
+        } | null;
+        step: SupplyStep;
+        statusMsg: string;
+        txHash: string | null;
+        isExecuting: boolean;
+        error: string | null;
+        showStatusPanel: boolean;
+        paymentResult: PaymentResult | null;
+    };
+    flags: {
+        directExecutionFeeNote: boolean;
+    };
+    retryFinalization: () => void;
+    fundEmbeddedSource: (amount: bigint) => Promise<void>;
+    canExecute: boolean;
+    submitSupply: () => Promise<void>;
+    submitPay: () => Promise<void>;
+    retrySupply: () => void;
+    dismissPaymentStatus: () => void;
+    resolveMaxAmount: (asset: Asset) => Promise<string | null>;
+    resetAfterSuccess: () => void;
+    resetPaymentState: () => void;
+};
+export type UseSpiceSupplyResult = ReturnType<typeof useSpiceSupply>;

package/dist/hooks/useSupplyAssets.d.ts

@@ -1,40 +1,42 @@
-import { type Address } from "viem";
 import type { Asset } from "../types/assets";
+import type { DestinationTokenConfig } from "../types/supply";
+import { isSupportedSource } from "../utils/assetPolicy";
+import type { InventoryToken } from "../utils/inventoryStore";
 export declare function compareSupplyAssets(a: Asset & {
     _source?: string;
 }, b: Asset & {
     _source?: string;
 }, destToken: string, destChain: number): number;
-export declare function isSupportedSupplyAsset(asset: Pick<Asset, "address" | "chainTokens">, supportedSourceAssets?: string[]): boolean;
-export declare function isSpendableSupplyAsset(asset: Pick<Asset, "address" | "chainTokens" | "chainId"> & {
+export declare const isSupportedSupplyAsset: typeof isSupportedSource;
+export declare function isSpendableSupplyAsset(asset: Pick<Asset, "address" | "chainId" | "chainTokens"> & {
     _source?: string;
-}, destinationChainId: number, supportedSourceAssets?: string[]): boolean;
-export declare function isSpendableExternalAsset(asset: Pick<Asset, "address" | "chainTokens" | "chainId"> & {
-    _source?: string;
-}, destinationToken: Pick<DestinationToken, "address" | "chainId">, supportedSourceAssets?: string[]): boolean;
-type DestinationToken = {
-    address: Address;
-    decimals: number;
-    symbol: string;
-    chainId: number;
-    logoURI?: string;
-};
+    isNative?: boolean;
+}, destinationChainId: number, supportedSourceAssets?: string[], _options?: {
+    allowPivot?: boolean;
+}): boolean;
+export declare const isSpendablePayAsset: typeof isSpendableSupplyAsset;
+export declare function isSpendableExternalAsset(asset: Parameters<typeof isSpendableSupplyAsset>[0], destinationToken: Pick<DestinationTokenConfig, "address" | "chainId">, supportedSourceAssets?: string[], options?: {
+    allowPivot?: boolean;
+}): boolean;
 export declare function useSupplyAssets(opts: {
     address: string | undefined;
-    destinationToken: DestinationToken;
+    destinationToken: DestinationTokenConfig;
     supportedSourceAssets?: string[];
     sourceChains?: number[];
     enabled: boolean;
+    includeExternalWalletAssets?: boolean;
+    includeCrossChainEmbeddedAssets?: boolean;
+    additionalSourceTokens?: InventoryToken[];
 }): {
-    displayAssets: (Asset & {
-        _source: "wallet" | "spice";
-    })[];
+    displayAssets: Asset[];
     filteredSpiceAssets: Asset[];
     walletAssets: Asset[];
     embeddedWalletAddress: `0x${string}` | undefined;
     externalAddress: `0x${string}` | undefined;
     isNon7702: boolean;
     refreshSpiceAssets: () => Promise<void>;
-    refreshWalletAssets: () => void;
+    refreshWalletAssets: () => Promise<void>;
+    loading: boolean;
+    refreshing: boolean | undefined;
+    error: string | null;
 };
-export {};