@gatedpath/frontend-kit 0.2.0 → 0.2.2

package/README.md

@@ -58,6 +58,23 @@ State derivation, in order: no address is `disconnected`; nothing cached and an
 says; `isEligible` false is `ineligible`; `isEligible` true with an expiry inside the window is
 `expiring`; otherwise `eligible`.
 
+## The register hook
+
+```tsx
+const r = useRegister(tokenAddress, address);
+// r.state: 'disconnected' | 'checking' | 'not-a-register' | 'registered' | 'not-registered' | 'frozen' | 'paused' | 'error'
+```
+
+`useRegister(token, wallet)` reads an ERC-3643 register (a T-REX token, the shape of every real asset
+on this network) and, when a wallet is given, whether that register's identity registry has verified
+it. It is the third gate a holder meets, after `permission.isAllowed` and a dApp's recipe, which
+`useEligibility` reads. The result carries the token's facts (name, symbol, decimals, supply, T-REX
+version, paused), the registry's shape (trusted issuers, required claim topics, and `gate`:
+`registration only` when no topics are required, `claims` otherwise) and the wallet's standing
+(verified, registered, frozen, balance). Reads are batched through Multicall3, cached per chain and
+refetched on a new block. Only the issuer can register a wallet, so `not-registered` is information
+for the page, never a button. The ops kit's `readRegister` is the same read from a script.
+
 ## The components
 
 | Component | State | Says |

package/dist/abi.d.ts

@@ -96,3 +96,234 @@ export declare const receptorMockStatusAbi: readonly [{
         readonly type: "uint8";
     }];
 }];
+/**
+ * ERC-3643 (T-REX 4.1.x), the shape of every real register on this network (RESEARCH.md source log,
+ * 12 October 2026): the token, its identity registry, the trusted-issuers and claim-topics registries.
+ * Reads only; the interface was confirmed against a live mainnet register before it was written here.
+ */
+export declare const registerTokenAbi: readonly [{
+    readonly type: "function";
+    readonly name: "identityRegistry";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "compliance";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "onchainID";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "paused";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "isFrozen";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getFrozenTokens";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}];
+export declare const identityRegistryAbi: readonly [{
+    readonly type: "function";
+    readonly name: "identityStorage";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "issuersRegistry";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "topicsRegistry";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "isVerified";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "identity";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "investorCountry";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint16";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "contains";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}];
+export declare const trustedIssuersRegistryAbi: readonly [{
+    readonly type: "function";
+    readonly name: "getTrustedIssuers";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getTrustedIssuerClaimTopics";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "issuer";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+}];
+export declare const claimTopicsRegistryAbi: readonly [{
+    readonly type: "function";
+    readonly name: "getClaimTopics";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+}];

package/dist/abi.js

@@ -77,3 +77,38 @@ export const receptorMockStatusAbi = [
         outputs: [{ name: '', type: 'uint8' }],
     },
 ];
+/**
+ * ERC-3643 (T-REX 4.1.x), the shape of every real register on this network (RESEARCH.md source log,
+ * 12 October 2026): the token, its identity registry, the trusted-issuers and claim-topics registries.
+ * Reads only; the interface was confirmed against a live mainnet register before it was written here.
+ */
+export const registerTokenAbi = [
+    { type: 'function', name: 'identityRegistry', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'compliance', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'onchainID', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'name', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'string' }] },
+    { type: 'function', name: 'symbol', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'string' }] },
+    { type: 'function', name: 'decimals', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'uint8' }] },
+    { type: 'function', name: 'totalSupply', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'uint256' }] },
+    { type: 'function', name: 'version', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'string' }] },
+    { type: 'function', name: 'paused', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'bool' }] },
+    { type: 'function', name: 'isFrozen', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'bool' }] },
+    { type: 'function', name: 'getFrozenTokens', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'uint256' }] },
+    { type: 'function', name: 'balanceOf', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'uint256' }] },
+];
+export const identityRegistryAbi = [
+    { type: 'function', name: 'identityStorage', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'issuersRegistry', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'topicsRegistry', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'isVerified', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'bool' }] },
+    { type: 'function', name: 'identity', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'address' }] },
+    { type: 'function', name: 'investorCountry', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'uint16' }] },
+    { type: 'function', name: 'contains', stateMutability: 'view', inputs: [{ name: 'wallet', type: 'address' }], outputs: [{ name: '', type: 'bool' }] },
+];
+export const trustedIssuersRegistryAbi = [
+    { type: 'function', name: 'getTrustedIssuers', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'address[]' }] },
+    { type: 'function', name: 'getTrustedIssuerClaimTopics', stateMutability: 'view', inputs: [{ name: 'issuer', type: 'address' }], outputs: [{ name: '', type: 'uint256[]' }] },
+];
+export const claimTopicsRegistryAbi = [
+    { type: 'function', name: 'getClaimTopics', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'uint256[]' }] },
+];

package/dist/dev/DevStatePanel.d.ts

@@ -5,7 +5,7 @@ export interface DevStatePanelProps {
     className?: string;
 }
 /**
- * The dev-only state switcher (PLAN.md 18.1). Lists the five wallets `npm run dev` seeded, marks
+ * The dev-only state switcher (the local loop). Lists the five wallets `npm run dev` seeded, marks
  * the connected one, and flips the connected wallet through the five credential states by calling
  * `setStatus` on the `ReceptorMock` as the deployer, through Anvil's impersonation RPC. Every
  * mounted `useEligibility` for that wallet refetches on the resulting signal, so the page moves

package/dist/dev/DevStatePanel.js

@@ -23,7 +23,7 @@ function rpc(client, method, params = []) {
     return client.request({ method, params });
 }
 /**
- * The dev-only state switcher (PLAN.md 18.1). Lists the five wallets `npm run dev` seeded, marks
+ * The dev-only state switcher (the local loop). Lists the five wallets `npm run dev` seeded, marks
  * the connected one, and flips the connected wallet through the five credential states by calling
  * `setStatus` on the `ReceptorMock` as the deployer, through Anvil's impersonation RPC. Every
  * mounted `useEligibility` for that wallet refetches on the resulting signal, so the page moves

package/dist/dev/index.js

@@ -1,4 +1,4 @@
-// `@gatedpath/frontend-kit/dev`: the local-loop pieces (PLAN.md 18.1). Import this path only from
+// `@gatedpath/frontend-kit/dev`: the local-loop pieces (the local loop). Import this path only from
 // code a dev server runs; the scaffold's `web/src/components/DevState.tsx` does, behind a build-time
 // check that leaves nothing of it in a production bundle.
 export { DevStatePanel } from './DevStatePanel.js';

package/dist/dev/localDeployment.d.ts

@@ -12,9 +12,9 @@ export interface LocalWallet {
     note: string;
 }
 /**
- * `deployments/local.json` as `scripts/dev.mjs` writes it in a scaffold (PLAN.md 18.1). `deployer`
+ * `deployments/local.json` as `scripts/dev.mjs` writes it in a scaffold (the local loop). `deployer`
  * is Anvil account 7, the account that deployed the mock and holds the contract's admin roles; the
- * panel impersonates it to call `setStatus`. Accounts 0 and 1 are never used (RESEARCH.md 30).
+ * panel impersonates it to call `setStatus`. Accounts 0 and 1 are never used (research question 30 on the builder site).
  */
 export interface LocalDeployment {
     chainId: number;

package/dist/index.d.ts

@@ -4,7 +4,9 @@ export { receptorMockExpiry } from './expiry.js';
 export { notifyEligibilityChanged, onEligibilityChanged } from './events.js';
 export { EligibilityGate, NotConnected, NotVerified, Ineligible, Eligible, ExpiringSoon, Checking, EligibilityError, LastChecked, GasWarning, } from './components.js';
 export type { EligibilityGateProps, StateProps, NotVerifiedProps, IneligibleProps, ExpiringSoonProps, EligibilityErrorProps, LastCheckedProps, GasWarningProps, } from './components.js';
-export { verifierAbi, permissionAbi, receptorMockAbi, receptorMockStatusAbi } from './abi.js';
+export { verifierAbi, permissionAbi, receptorMockAbi, receptorMockStatusAbi, registerTokenAbi, identityRegistryAbi, trustedIssuersRegistryAbi, claimTopicsRegistryAbi } from './abi.js';
+export { useRegister } from './useRegister.js';
+export type { RegisterState, RegisterResult, UseRegisterOptions } from './useRegister.js';
 export { ACCESS_URL, FAUCET_URL, VINE_INTERACTION_URL, VINE_FEES_URL } from './urls.js';
 export { explainError } from './explainError.js';
 export type { ExplainedError, ExplainErrorOptions } from './explainError.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export { useEligibility } from './useEligibility.js';
 export { receptorMockExpiry } from './expiry.js';
 export { notifyEligibilityChanged, onEligibilityChanged } from './events.js';
 export { EligibilityGate, NotConnected, NotVerified, Ineligible, Eligible, ExpiringSoon, Checking, EligibilityError, LastChecked, GasWarning, } from './components.js';
-export { verifierAbi, permissionAbi, receptorMockAbi, receptorMockStatusAbi } from './abi.js';
+export { verifierAbi, permissionAbi, receptorMockAbi, receptorMockStatusAbi, registerTokenAbi, identityRegistryAbi, trustedIssuersRegistryAbi, claimTopicsRegistryAbi } from './abi.js';
+export { useRegister } from './useRegister.js';
 export { ACCESS_URL, FAUCET_URL, VINE_INTERACTION_URL, VINE_FEES_URL } from './urls.js';
 export { explainError } from './explainError.js';

package/dist/useRegister.d.ts

@@ -0,0 +1,55 @@
+import type { Address } from './useEligibility.js';
+/**
+ * Where a wallet stands with one ERC-3643 register, in words a page can switch on.
+ * `not-a-register`: the address does not answer `identityRegistry()` with a contract.
+ * `registered`: the register's identity registry has verified this wallet.
+ * `not-registered`: it has not; only the issuer can change that.
+ * `frozen`: verified, but the issuer has frozen this wallet's tokens.
+ * `paused`: the issuer has paused every transfer of this register.
+ */
+export type RegisterState = 'disconnected' | 'checking' | 'not-a-register' | 'registered' | 'not-registered' | 'frozen' | 'paused' | 'error';
+export interface UseRegisterOptions {
+    chainId?: number;
+    /** Refetch floor in milliseconds; the reads also refetch on every new block. Default 30 000. */
+    refreshInterval?: number;
+    watchBlocks?: boolean;
+    enabled?: boolean;
+}
+export interface RegisterResult {
+    state: RegisterState;
+    /** The token's own facts, when it is a register. */
+    token: {
+        name: string | null;
+        symbol: string | null;
+        decimals: number | null;
+        totalSupply: bigint | null;
+        version: string | null;
+        paused: boolean | null;
+        identityRegistry: Address | null;
+    };
+    /** The registry's shape: which issuers it trusts and which claim topics it requires. */
+    registry: {
+        trustedIssuers: Address[];
+        claimTopics: bigint[];
+        gate: 'registration only' | 'claims' | null;
+    };
+    /** The wallet's standing, when a wallet was given. */
+    wallet: {
+        isVerified: boolean | null;
+        registered: boolean | null;
+        frozen: boolean | null;
+        balance: bigint | null;
+    } | null;
+    blockNumber: bigint | undefined;
+    isFetching: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+/**
+ * Reads an ERC-3643 register (a T-REX token) and, if a wallet is given, whether that register's
+ * identity registry has verified it. The third of the three gates a holder meets on this network,
+ * after `permission.isAllowed` and a dApp's recipe (`useEligibility`). Read-only; batched through
+ * Multicall3 by wagmi; cached per chain and refetched on a new block. Only the issuer can register a
+ * wallet, so a `not-registered` answer is information for the page, never a button.
+ */
+export declare function useRegister(token: Address | undefined, wallet: Address | undefined, options?: UseRegisterOptions): RegisterResult;

package/dist/useRegister.js

@@ -0,0 +1,146 @@
+'use client';
+import { useEffect, useMemo, useRef } from 'react';
+import { useBlockNumber, useChainId, useReadContracts } from 'wagmi';
+import { registerTokenAbi, identityRegistryAbi, claimTopicsRegistryAbi, trustedIssuersRegistryAbi } from './abi.js';
+const ZERO = '0x0000000000000000000000000000000000000000';
+/**
+ * Reads an ERC-3643 register (a T-REX token) and, if a wallet is given, whether that register's
+ * identity registry has verified it. The third of the three gates a holder meets on this network,
+ * after `permission.isAllowed` and a dApp's recipe (`useEligibility`). Read-only; batched through
+ * Multicall3 by wagmi; cached per chain and refetched on a new block. Only the issuer can register a
+ * wallet, so a `not-registered` answer is information for the page, never a button.
+ */
+export function useRegister(token, wallet, options = {}) {
+    const currentChainId = useChainId();
+    const chainId = options.chainId ?? currentChainId;
+    const refreshInterval = options.refreshInterval ?? 30_000;
+    const watchBlocks = options.watchBlocks ?? true;
+    const enabled = (options.enabled ?? true) && Boolean(token);
+    const block = useBlockNumber({ chainId, watch: watchBlocks && enabled, query: { enabled: watchBlocks && enabled } });
+    const query = { enabled, staleTime: refreshInterval, refetchInterval: refreshInterval, refetchOnWindowFocus: false };
+    // Pass one: the token. `identityRegistry()` decides whether there is a register at all.
+    const tokenReads = useReadContracts({
+        allowFailure: true,
+        contracts: [
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'identityRegistry', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'name', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'symbol', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'decimals', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'totalSupply', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'version', chainId },
+            { address: (token ?? ZERO), abi: registerTokenAbi, functionName: 'paused', chainId },
+        ],
+        query,
+    });
+    const t = tokenReads.data;
+    const registryAddress = (t?.[0]?.status === 'success' ? t[0].result : null) ?? null;
+    const isRegister = registryAddress !== null && registryAddress !== ZERO;
+    // Pass two: the registry's shape and the wallet's standing, once the registry is known.
+    // The wallet reads are always in the batch, against the zero address when no wallet is given, so the
+    // batch has one shape and the results can be read by position. Those answers are ignored without a wallet.
+    const who = (wallet ?? ZERO);
+    const registryFor = (registryAddress ?? ZERO);
+    const tokenFor = (token ?? ZERO);
+    const detailReads = useReadContracts({
+        allowFailure: true,
+        contracts: [
+            { address: registryFor, abi: identityRegistryAbi, functionName: 'issuersRegistry', chainId },
+            { address: registryFor, abi: identityRegistryAbi, functionName: 'topicsRegistry', chainId },
+            { address: registryFor, abi: identityRegistryAbi, functionName: 'isVerified', args: [who], chainId },
+            { address: registryFor, abi: identityRegistryAbi, functionName: 'identity', args: [who], chainId },
+            { address: tokenFor, abi: registerTokenAbi, functionName: 'isFrozen', args: [who], chainId },
+            { address: tokenFor, abi: registerTokenAbi, functionName: 'balanceOf', args: [who], chainId },
+        ],
+        query: { ...query, enabled: enabled && isRegister },
+    });
+    const d = detailReads.data;
+    const issuersRegistry = d?.[0]?.status === 'success' ? d[0].result : null;
+    const topicsRegistry = d?.[1]?.status === 'success' ? d[1].result : null;
+    // Pass three: the issuers and the topics.
+    const shapeReads = useReadContracts({
+        allowFailure: true,
+        contracts: [
+            { address: (issuersRegistry ?? ZERO), abi: trustedIssuersRegistryAbi, functionName: 'getTrustedIssuers', chainId },
+            { address: (topicsRegistry ?? ZERO), abi: claimTopicsRegistryAbi, functionName: 'getClaimTopics', chainId },
+        ],
+        query: { ...query, enabled: enabled && Boolean(issuersRegistry && topicsRegistry) },
+    });
+    const s = shapeReads.data;
+    const refresh = async () => {
+        await Promise.all([tokenReads.refetch(), detailReads.refetch(), shapeReads.refetch()]);
+    };
+    // Refetch on a new block, and only on a new block: wagmi polls the block number for us.
+    const lastBlock = useRef(undefined);
+    const refetchToken = tokenReads.refetch;
+    const refetchDetail = detailReads.refetch;
+    const refetchShape = shapeReads.refetch;
+    useEffect(() => {
+        if (!watchBlocks || !enabled || block.data === undefined)
+            return;
+        if (lastBlock.current === undefined) {
+            lastBlock.current = block.data;
+            return;
+        }
+        if (block.data !== lastBlock.current) {
+            lastBlock.current = block.data;
+            void refetchToken();
+            if (isRegister)
+                void refetchDetail();
+            if (issuersRegistry && topicsRegistry)
+                void refetchShape();
+        }
+    }, [block.data, watchBlocks, enabled, isRegister, issuersRegistry, topicsRegistry, refetchToken, refetchDetail, refetchShape]);
+    return useMemo(() => {
+        const ok = (r) => (r && r.status === 'success' ? r.result : null);
+        const error = (tokenReads.error ?? detailReads.error ?? shapeReads.error);
+        const trustedIssuers = (ok(s?.[0]) ?? []);
+        const claimTopics = (ok(s?.[1]) ?? []);
+        const paused = ok(t?.[6]);
+        const isVerified = wallet ? ok(d?.[2]) : null;
+        const identity = wallet ? ok(d?.[3]) : null;
+        const frozen = wallet ? ok(d?.[4]) : null;
+        const balance = wallet ? ok(d?.[5]) : null;
+        let state;
+        if (!token)
+            state = 'disconnected';
+        else if (error)
+            state = 'error';
+        else if (tokenReads.isPending)
+            state = 'checking';
+        else if (!isRegister)
+            state = 'not-a-register';
+        else if (wallet && detailReads.isPending)
+            state = 'checking';
+        else if (paused)
+            state = 'paused';
+        else if (wallet && frozen)
+            state = 'frozen';
+        else if (wallet)
+            state = isVerified ? 'registered' : 'not-registered';
+        else
+            state = 'registered';
+        return {
+            state,
+            token: {
+                name: ok(t?.[1]),
+                symbol: ok(t?.[2]),
+                decimals: ok(t?.[3]),
+                totalSupply: ok(t?.[4]),
+                version: ok(t?.[5]),
+                paused,
+                identityRegistry: isRegister ? registryAddress : null,
+            },
+            registry: {
+                trustedIssuers,
+                claimTopics,
+                gate: isRegister && s ? (claimTopics.length === 0 ? 'registration only' : 'claims') : null,
+            },
+            wallet: wallet && isRegister ? { isVerified, registered: identity !== null && identity !== ZERO, frozen, balance } : null,
+            blockNumber: block.data,
+            isFetching: tokenReads.isFetching || detailReads.isFetching || shapeReads.isFetching,
+            error,
+            refresh,
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [token, wallet, t, d, s, isRegister, registryAddress, tokenReads.isPending, detailReads.isPending, tokenReads.isFetching, detailReads.isFetching, shapeReads.isFetching, tokenReads.error, detailReads.error, shapeReads.error, block.data]);
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@gatedpath/frontend-kit",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "React components and one hook for the five eligibility states every Redbelly dApp has: not connected, connected but not verified on the network, verified but ineligible for this action, eligible, credential expiring soon; plus explainError, the plain words for a viem or wagmi error from the shared failure table. wagmi + viem, headless with a small default style.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tshirtdropper/redbelly-development-tool.git",
+    "url": "git+https://github.com/gatedpath/builder-path.git",
     "directory": "packages/frontend-kit"
   },
   "publishConfig": {