@b3dotfun/sdk 0.1.70-alpha.18 → 0.1.70-alpha.19

package/dist/cjs/global-account/react/hooks/useFirstEOA.js

@@ -8,6 +8,7 @@ const react_2 = require("react");
 const viem_1 = require("thirdweb/adapters/viem");
 const react_3 = require("thirdweb/react");
 const debug = (0, debug_1.debugB3React)("useFirstEOA");
+// Explicit return annotation keeps the hook's declaration portable (TS2742).
 function useFirstEOA(chain) {
     const wallets = (0, react_3.useConnectedWallets)();
     const isConnected = (0, react_1.useAuthStore)(state => state.isConnected);

package/dist/cjs/global-account/react/hooks/usePortfolioBalance.d.ts

@@ -0,0 +1,15 @@
+import { type B3TokenBalance } from "../../../shared/utils/zerionPositions";
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+export declare function usePortfolioBalance(address?: string, chainIds?: number[]): import("@tanstack/react-query").UseQueryResult<B3TokenBalance[], Error>;
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+export declare function usePortfolioTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number): import("@tanstack/react-query").UseQueryResult<B3TokenBalance | undefined, Error>;

package/dist/cjs/global-account/react/hooks/usePortfolioBalance.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePortfolioBalance = usePortfolioBalance;
+exports.usePortfolioTokenBalance = usePortfolioTokenBalance;
+const react_query_1 = require("@tanstack/react-query");
+const zerionPositions_1 = require("../../../shared/utils/zerionPositions");
+/**
+ * Wallet holdings, read through the b3 portfolio proxy.
+ *
+ * The proxy holds the upstream API key server-side and authorizes browsers by Origin allowlist, so
+ * nothing secret ships to the client and no key is accepted from it. A consumer served from an
+ * origin the proxy does not know will be refused — adding an origin is a proxy config change, not
+ * an SDK change.
+ */
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+/**
+ * Fetch every spendable holding for a wallet in one request.
+ *
+ * Deliberately unpaginated and unfiltered by chain. The positions endpoint returns a wallet's full
+ * simple-position list in a single response, and passing a chain filter is actively harmful: the
+ * upstream rejects a handful of otherwise-valid chain slugs and fails the WHOLE request when one
+ * appears, so a caller asking for five chains can lose all five. Callers narrow the result instead.
+ */
+async function fetchWalletPositions(address) {
+    const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/positions/?filter[positions]=only_simple`;
+    const response = await fetch(url, { headers: { Accept: "application/json" } });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch wallet balances: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return (0, zerionPositions_1.adaptZerionPositions)(body.data ?? []);
+}
+/**
+ * Keyed by wallet alone so every consumer of the same wallet shares one fetch and one cache entry.
+ * Keying by the requested chain subset instead would refetch per caller and share nothing.
+ */
+function walletPositionsQueryKey(address) {
+    return ["walletPositions", address];
+}
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+function usePortfolioBalance(address, chainIds) {
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return (0, react_query_1.useQuery)({
+        queryKey: walletPositionsQueryKey(address),
+        queryFn: () => {
+            if (!address)
+                throw new Error("Address is required");
+            return fetchWalletPositions(address);
+        },
+        enabled: Boolean(address),
+        select: (balances) => wantedChainIds ? balances.filter(balance => wantedChainIds.includes(balance.chain_id)) : balances,
+    });
+}
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+function usePortfolioTokenBalance(walletAddress, tokenAddress, chainId) {
+    return (0, react_query_1.useQuery)({
+        queryKey: walletPositionsQueryKey(walletAddress),
+        queryFn: () => {
+            if (!walletAddress)
+                throw new Error("Address is required");
+            return fetchWalletPositions(walletAddress);
+        },
+        enabled: Boolean(walletAddress) && Boolean(tokenAddress) && Boolean(chainId),
+        select: (balances) => balances.find(balance => balance.chain_id === chainId && (0, zerionPositions_1.balanceMatchesToken)(balance, tokenAddress ?? "")),
+    });
+}

package/dist/cjs/global-account/react/hooks/usePortfolioCollectibles.d.ts

@@ -0,0 +1,12 @@
+import type { SimpleHashNFTResponse } from "../../../global-account/types/simplehash.types";
+/**
+ * NFTs held by a wallet, in the SimpleHash shape `AccountAssets` already renders.
+ *
+ * Chain narrowing happens here rather than in the request: the upstream rejects some valid chain
+ * slugs outright and fails the whole request when one is present, so asking for a subset can cost
+ * you the whole answer.
+ */
+export declare function usePortfolioCollectibles(address?: string, chainIds?: number[], options?: {
+    limit?: number;
+    filterSpam?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<SimpleHashNFTResponse, Error>;

package/dist/cjs/global-account/react/hooks/usePortfolioCollectibles.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePortfolioCollectibles = usePortfolioCollectibles;
+const zerionPositions_1 = require("../../../shared/utils/zerionPositions");
+const react_query_1 = require("@tanstack/react-query");
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+/** Caps an ERC-1155 balance string at MAX_SAFE_INTEGER so a huge supply cannot overflow. */
+function safeParseBalance(balance) {
+    if (!balance)
+        return 1;
+    const parsed = parseInt(balance, 10);
+    if (Number.isNaN(parsed))
+        return 1;
+    return Math.min(parsed, Number.MAX_SAFE_INTEGER);
+}
+/**
+ * Reshape one Zerion NFT position into the SimpleHash record `AccountAssets` renders.
+ *
+ * Fields Zerion does not carry — traits, rarity, royalties, sale history — stay empty rather than
+ * being synthesised from something adjacent. In particular the position's `price` is a current
+ * estimate, not a sale, so it must not be written into `last_sale`.
+ */
+function toSimpleHashNft(position, ownerAddress) {
+    const attributes = position.attributes ?? {};
+    const nftInfo = attributes.nft_info;
+    const slug = position.relationships?.chain?.data?.id;
+    if (!nftInfo?.contract_address || !nftInfo.token_id || !slug)
+        return null;
+    const imageUrl = nftInfo.content?.detail?.url ?? nftInfo.content?.preview?.url ?? "";
+    const collectionInfo = attributes.collection_info ?? {};
+    const acquiredAt = attributes.changed_at ?? "";
+    return {
+        nft_id: `${slug}.${nftInfo.contract_address}.${nftInfo.token_id}`,
+        chain: slug,
+        contract_address: nftInfo.contract_address,
+        token_id: nftInfo.token_id,
+        name: nftInfo.name || "",
+        description: collectionInfo.description || "",
+        previews: {
+            image_small_url: nftInfo.content?.preview?.url ?? imageUrl,
+            image_medium_url: imageUrl,
+            image_large_url: imageUrl,
+            image_opengraph_url: imageUrl,
+            blurhash: "",
+            predominant_color: "",
+        },
+        image_url: imageUrl,
+        image_properties: { width: 0, height: 0, size: 0, mime_type: "", exif_orientation: null },
+        video_url: null,
+        video_properties: null,
+        audio_url: null,
+        audio_properties: null,
+        model_url: null,
+        model_properties: null,
+        other_url: null,
+        other_properties: null,
+        background_color: null,
+        external_url: null,
+        created_date: "",
+        status: "minted",
+        token_count: 1,
+        owner_count: 1,
+        owners: [
+            {
+                owner_address: ownerAddress,
+                quantity: safeParseBalance(attributes.amount),
+                quantity_string: attributes.amount || "1",
+                first_acquired_date: acquiredAt,
+                last_acquired_date: acquiredAt,
+            },
+        ],
+        contract: {
+            type: nftInfo.interface === "ERC1155" ? "ERC1155" : "ERC721",
+            name: collectionInfo.name || "",
+            symbol: null,
+            deployed_by: "",
+            deployed_via_contract: "",
+            owned_by: "",
+            has_multiple_collections: false,
+        },
+        collection: {
+            collection_id: nftInfo.contract_address,
+            name: collectionInfo.name || "Unknown Collection",
+            description: collectionInfo.description ?? null,
+            image_url: collectionInfo.content?.icon?.url ?? "",
+            image_properties: { width: 0, height: 0, mime_type: "" },
+            banner_image_url: null,
+            category: null,
+            is_nsfw: null,
+            external_url: null,
+            twitter_username: null,
+            discord_url: null,
+            instagram_username: null,
+            medium_username: null,
+            telegram_url: null,
+            marketplace_pages: [],
+            metaplex_mint: null,
+            metaplex_candy_machine: null,
+            metaplex_first_verified_creator: null,
+            floor_prices: [],
+            top_bids: [],
+            distinct_owner_count: 0,
+            distinct_nft_count: 0,
+            total_quantity: 0,
+            chains: [slug],
+            top_contracts: [nftInfo.contract_address],
+            collection_royalties: [],
+        },
+        last_sale: null,
+        primary_sale: null,
+        first_created: {
+            minted_to: ownerAddress,
+            quantity: 1,
+            quantity_string: "1",
+            timestamp: "",
+            block_number: 0,
+            transaction: "",
+            transaction_initiator: "",
+        },
+        rarity: { rank: null, score: null, unique_attributes: null },
+        royalty: [],
+        extra_metadata: {
+            attributes: [],
+            image_original_url: imageUrl,
+            animation_original_url: null,
+            metadata_original_url: "",
+        },
+    };
+}
+/**
+ * NFTs held by a wallet, in the SimpleHash shape `AccountAssets` already renders.
+ *
+ * Chain narrowing happens here rather than in the request: the upstream rejects some valid chain
+ * slugs outright and fails the whole request when one is present, so asking for a subset can cost
+ * you the whole answer.
+ */
+function usePortfolioCollectibles(address, chainIds, options) {
+    const limit = options?.limit;
+    const filterSpam = options?.filterSpam;
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return (0, react_query_1.useQuery)({
+        queryKey: ["walletCollectibles", address, limit, filterSpam],
+        queryFn: async () => {
+            if (!address)
+                throw new Error("Address is required");
+            const params = new URLSearchParams();
+            if (limit)
+                params.set("page[size]", String(limit));
+            const query = params.toString();
+            const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/nft-positions/${query ? `?${query}` : ""}`;
+            const response = await fetch(url, { headers: { Accept: "application/json" } });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch collectibles: ${response.status} ${response.statusText}`);
+            }
+            const body = (await response.json());
+            // Spam is dropped here, not in `select`: the flag lives on the raw position and the
+            // SimpleHash shape has nowhere to carry it downstream.
+            const nfts = (body.data ?? [])
+                .filter(position => !(filterSpam && position.attributes?.nft_info?.flags?.is_spam === true))
+                .map(position => toSimpleHashNft(position, address))
+                .filter((nft) => nft !== null);
+            return { next_cursor: null, next: null, previous: null, nfts };
+        },
+        enabled: Boolean(address),
+        staleTime: 30 * 1000,
+        gcTime: 5 * 60 * 1000,
+        select: (data) => {
+            if (!wantedChainIds)
+                return data;
+            const all = data.nfts ?? [];
+            const nfts = all.filter(nft => {
+                const chainId = (0, zerionPositions_1.zerionSlugToChainId)(nft.chain);
+                return chainId !== undefined && wantedChainIds.includes(chainId);
+            });
+            return nfts.length === all.length ? data : { ...data, nfts };
+        },
+    });
+}

package/dist/cjs/global-account/react/stores/useModalStore.d.ts

@@ -649,8 +649,6 @@ export interface AnySpendDepositModalProps extends BaseModalProps {
     showChainSelection?: boolean;
     /** Whether to show the "Fund with Fiat" option in the deposit options list. Defaults to true */
     showFiatOption?: boolean;
-    /** Minimum pool size for filtering tokens (default: 1,000,000) */
-    minPoolSize?: number;
     /** Custom title for chain selection step */
     chainSelectionTitle?: string;
     /** Custom description for chain selection step */

package/dist/cjs/global-account/react/utils/createWagmiConfig.d.ts

@@ -13,6 +13,6 @@ export interface CreateWagmiConfigOptions {
  * @param options.connectors - Additional connectors to include
  * @param options.overrideDefaultConnectors - If true, only use provided connectors (ignores defaults)
  */
-export declare function createWagmiConfig(options: CreateWagmiConfigOptions): import("wagmi").Config<readonly [import("viem").Chain, ...import("viem").Chain[]], {
-    [k: string]: import("viem").HttpTransport<undefined, false>;
+export declare function createWagmiConfig(options: CreateWagmiConfigOptions): import("wagmi").Config<readonly [any, ...any[]], {
+    [k: string]: any;
 }, CreateConnectorFn[]>;

package/dist/cjs/shared/constants/chains/b3Chain.d.ts

@@ -37,11 +37,23 @@ export declare const b3Mainnet: {
         };
     };
     sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly rpc: "https://mainnet-rpc.b3.fun";
     readonly icon: {
         readonly url: "https://cdn.b3.fun/b3_logo.svg";
@@ -85,11 +97,23 @@ export declare const b3Chain: Chain | {
         };
     };
     sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     readonly rpc: "https://mainnet-rpc.b3.fun";
     readonly icon: {
         readonly url: "https://cdn.b3.fun/b3_logo.svg";

package/dist/cjs/shared/constants/chains/supported.d.ts

@@ -1,7 +1,7 @@
 import type { Chain as ThirdwebChain } from "thirdweb";
-export declare const supportedChains: import("viem").Chain[];
+export declare const supportedChains: any;
 export declare const supportedChainsTW: ThirdwebChain[];
-export declare const supportedChainNetworks: import("@b3/chain-registry").ChainDefinition[];
+export declare const supportedChainNetworks: any;
 export declare const coingeckoChains: Record<number, {
     coingecko_id: string;
     name: string;
@@ -15,7 +15,7 @@ export declare function getCoingeckoChainInfo(chainId: number): {
 export declare const b3MainnetThirdWeb: Readonly<import("thirdweb/chains").ChainOptions & {
     rpc: string;
 }>;
-export declare const b3Mainnet: import("viem").Chain;
-export declare const baseMainnet: import("viem").Chain;
+export declare const b3Mainnet: any;
+export declare const baseMainnet: any;
 export declare function getThirdwebChain(chainId: number): ThirdwebChain;
 export declare function getChainLogo(chainId: number): string;

package/dist/cjs/shared/constants/index.d.ts

@@ -1,7 +1,11 @@
+import type { Wallet } from "thirdweb/wallets";
 export * from "./currency";
 export declare const siteURL = "https://basement.fun";
 export declare const b3CoinIcon = "https://cdn.b3.fun/b3-coin-3d.png";
 export declare const ecosystemWalletId: `ecosystem.${string}`;
+export type EcosystemWallet = Wallet<`ecosystem.${string}`> & {
+    getAuthToken: () => string | null;
+};
 export declare const tokenIcons: {
     ETH: string;
     WETH: string;

package/dist/cjs/shared/utils/zerionPositions.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Canonical browser-side translation of Zerion wallet positions into B3 balance rows.
+ *
+ * This lives in the published SDK because every browser consumer needs it — the apps in this repo
+ * and the sites that install `@b3dotfun/sdk` from npm — and the in-repo Zerion client is a private
+ * workspace package that a published package cannot depend on. Backend services keep their own
+ * translation: pulling a browser SDK into a Node service to share one function is a worse trade
+ * than the second copy.
+ *
+ * Only the HTTP layer differs between callers. The rules below — which row counts as the chain's
+ * native coin, and which rows have no usable identity — must not be re-derived anywhere else.
+ */
+/** Address B3 uses for a chain's native coin on EVM. Matches NATIVE_TOKEN_ADDRESSES. */
+export declare const EVM_NATIVE_TOKEN_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export declare const SOLANA_NATIVE_TOKEN_ADDRESS = "So11111111111111111111111111111111111111112";
+export declare const SOLANA_ZERION_SLUG = "solana";
+/** Solana's chain id as the chain registry defines it — the id every balance row is keyed by. */
+export declare const SOLANA_CHAIN_ID = 7565164;
+export declare function zerionSlugToChainId(slug: string): number | undefined;
+export declare function chainIdToZerionSlug(chainId: number): string | undefined;
+export interface ZerionPositionQuantity {
+    int?: string;
+    decimals?: number;
+}
+export interface ZerionPositionImplementation {
+    chain_id?: string;
+    address?: string | null;
+    decimals?: number;
+}
+export interface ZerionPositionFungibleInfo {
+    name?: string;
+    symbol?: string;
+    icon?: {
+        url?: string;
+    } | null;
+    implementations?: ZerionPositionImplementation[];
+}
+export interface ZerionPositionLike {
+    id?: string;
+    attributes?: {
+        quantity?: ZerionPositionQuantity;
+        value?: number | null;
+        price?: number | null;
+        fungible_info?: ZerionPositionFungibleInfo;
+        flags?: {
+            displayable?: boolean;
+            is_trash?: boolean;
+        };
+    };
+    relationships?: {
+        chain?: {
+            data?: {
+                id?: string;
+            };
+        };
+    };
+}
+/** One spendable holding. `amount` is the raw integer; pair it with `decimals` to display. */
+export interface B3TokenBalance {
+    chain: string;
+    chain_id: number;
+    address: string;
+    amount: string;
+    symbol: string;
+    decimals: number;
+    /**
+     * Whether `address` is the native-coin sentinel rather than a real contract. Callers deciding
+     * between a value-bearing send and an ERC-20 `transfer` MUST branch on this, never on the
+     * sentinel string: getting it backwards spends gas and moves nothing.
+     */
+    is_native: boolean;
+    name?: string;
+    price_usd?: number;
+    value_usd?: number;
+    token_metadata?: {
+        logo: string;
+    };
+}
+export declare function nativeTokenAddressForChain(slug: string): string;
+/**
+ * Whether `balance` is the token identified by `tokenAddress`.
+ *
+ * Native coins are matched on the row's `is_native` flag rather than its printed address, because
+ * the caller and the adapter rarely spell the native coin the same way.
+ */
+export declare function balanceMatchesToken(balance: B3TokenBalance, tokenAddress: string): boolean;
+/**
+ * Adapt raw Zerion positions into balance rows, dropping any row we cannot describe honestly.
+ *
+ * A row is dropped when its chain slug is absent or unmapped, or when neither the quantity nor the
+ * chain implementation carries decimals — an amount rendered against a guessed scale is a wrong
+ * number presented as a real one, which is worse for the reader than a missing row.
+ *
+ * @param slugToChainId overrides slug resolution; return undefined to skip a chain entirely.
+ */
+export declare function adaptZerionPositions(positions: ZerionPositionLike[], slugToChainId?: (slug: string) => number | undefined): B3TokenBalance[];