@sodax/dapp-kit 2.0.0-rc.11 → 2.0.0-rc.13

package/src/providers/SodaxProvider.tsx

@@ -1,7 +1,6 @@
 import { useMemo, type ReactNode, type ReactElement } from 'react';
-import { Sodax, type SodaxConfig } from '@sodax/sdk';
+import { Sodax, type SodaxOptions } from '@sodax/sdk';
 import { SodaxContext } from '@/contexts/index.js';
-import type { DeepPartial } from '@sodax/sdk';
 
 interface SodaxProviderProps {
   children: ReactNode;
@@ -17,7 +16,7 @@ interface SodaxProviderProps {
    * <SodaxProvider config={config}>...</SodaxProvider>
    * ```
    */
-  config?: DeepPartial<SodaxConfig>;
+  config?: SodaxOptions;
 }
 
 /** Root provider for `@sodax/dapp-kit`. Must be paired with `QueryClientProvider`. */

package/src/utils/index.ts

@@ -1 +1,2 @@
 export * from './dex-utils.js';
+export * from './nearStorageGate.js';

package/src/utils/nearStorageGate.test.ts

@@ -0,0 +1,46 @@
+import { ChainKeys } from '@sodax/sdk';
+import { describe, expect, it } from 'vitest';
+import { resolveNearStorageGate } from './nearStorageGate.js';
+
+describe('resolveNearStorageGate', () => {
+  it('destination not NEAR → never gates', () => {
+    expect(resolveNearStorageGate(ChainKeys.POLYGON_MAINNET, { isLoading: false, data: false })).toEqual({
+      isNear: false,
+      needsRegistration: false,
+      blocksAction: false,
+    });
+  });
+
+  it('NEAR, check in flight → blocks action but does not yet prompt registration', () => {
+    expect(resolveNearStorageGate(ChainKeys.NEAR_MAINNET, { isLoading: true, data: undefined })).toEqual({
+      isNear: true,
+      needsRegistration: false,
+      blocksAction: true,
+    });
+  });
+
+  it('NEAR, check resolved, not registered → prompt registration and block action', () => {
+    expect(resolveNearStorageGate(ChainKeys.NEAR_MAINNET, { isLoading: false, data: false })).toEqual({
+      isNear: true,
+      needsRegistration: true,
+      blocksAction: true,
+    });
+  });
+
+  it('NEAR, check resolved, registered → no gate', () => {
+    expect(resolveNearStorageGate(ChainKeys.NEAR_MAINNET, { isLoading: false, data: true })).toEqual({
+      isNear: true,
+      needsRegistration: false,
+      blocksAction: false,
+    });
+  });
+
+  it('NEAR, query disabled (unresolved, not checking) → does not block', () => {
+    // isLoading is false for a disabled query; data stays undefined → action must not be blocked.
+    expect(resolveNearStorageGate(ChainKeys.NEAR_MAINNET, { isLoading: false, data: undefined })).toEqual({
+      isNear: true,
+      needsRegistration: false,
+      blocksAction: false,
+    });
+  });
+});

package/src/utils/nearStorageGate.ts

@@ -0,0 +1,39 @@
+import { ChainKeys, type SpokeChainKey } from '@sodax/sdk';
+import type { UseQueryResult } from '@tanstack/react-query';
+
+/** The subset of a `useNearStorageCheck` result the gate reads. A full `UseQueryResult<boolean>` satisfies it. */
+export type NearStorageCheckResult = Pick<UseQueryResult<boolean>, 'isLoading' | 'data'>;
+
+/** UI gate state for NEP-141 storage registration on NEAR. */
+export interface NearStorageGateState {
+  /** Destination is NEAR — the only chain with a NEP-141 storage-registration prerequisite. */
+  isNear: boolean;
+  /** Show the "register storage" action: the check resolved and the recipient is not registered. */
+  needsRegistration: boolean;
+  /**
+   * Keep the downstream action (swap/bridge/borrow/withdraw) disabled: the NEAR gate is unresolved
+   * (still checking) or unmet (needs registration).
+   */
+  blocksAction: boolean;
+}
+
+/**
+ * Derives the NEP-141 storage-registration UI gate state for a flow that delivers a token to a user
+ * on NEAR — NEAR's analogue of the Stellar trustline gate. Unwrapped (no hook): pass the destination
+ * `chainKey` and the `useNearStorageCheck` result; the util owns the `=== NEAR` test and reads
+ * `isLoading` (NOT `isPending`, which stays `true` for a disabled query and would block forever).
+ *
+ * `blocksAction` deliberately also covers the in-flight check window so the action can't be
+ * triggered before registration status is known; `needsRegistration` only flips once the check has
+ * resolved (so the "register" button isn't shown speculatively while still checking).
+ */
+export function resolveNearStorageGate(chainKey: SpokeChainKey, check: NearStorageCheckResult): NearStorageGateState {
+  const isNear = chainKey === ChainKeys.NEAR_MAINNET;
+  const isChecking = check.isLoading;
+  const isRegistered = check.data;
+  return {
+    isNear,
+    needsRegistration: isNear && !isChecking && isRegistered === false,
+    blocksAction: isNear && (isChecking || isRegistered === false),
+  };
+}