@b3dotfun/sdk 0.0.1-alpha.1

package/dist/esm/shared/utils/simplehash.js

@@ -0,0 +1,286 @@
+import { CLIENT_APP_BUNDLE_ID, THIRDWEB_CLIENT_ID, THIRDWEB_SECRET_KEY } from "../../shared/constants";
+import { getV1Nfts, getV1NftsByContractAddress, getV1NftsByContractAddressByTokenId, getV1NftsTransfersByContractAddress } from "../../shared/thirdweb/generated/sdk.gen";
+import { transformCollectionResponse, transformNFTResponse, transformTransferResponse } from "./insights";
+export * from "../../global-account/types/simplehash.types";
+export const simpleHashChainToChainId = (chain) => {
+    switch (chain) {
+        case "b3":
+            return 8333;
+        case "b3-sepolia":
+            return 1993;
+        case "base":
+            return 8453;
+        case "base-sepolia":
+            return 84532;
+        default:
+            return null;
+    }
+};
+export const simpleHashChainToChainName = (chain) => {
+    switch (chain) {
+        case 8333:
+            return "b3";
+        case 1993:
+            return "b3-sepolia";
+        case 8453:
+            return "base";
+        case 84532:
+            return "base-sepolia";
+        default:
+            return null;
+    }
+};
+const isServer = typeof window === "undefined";
+export async function fetchSimpleHashData(route, params = {}, fetchOptions) {
+    /**
+     * SimpleHash API to ThirdWeb Insights migration
+     *
+     * Take the approach below to migrate routes from SimpleHash API to ThirdWeb Insights
+     * This will allow us to
+     */
+    // Migrate NFT Owners
+    // TODO: This should support multi-wallet, like the original SimpleHash API
+    if (route === "/v0/nfts/owners") {
+        // Transform query params
+        const options = {
+            query: {
+                chain: params.chains?.split(",").map((chain) => simpleHashChainToChainId(chain)),
+                owner_address: params.wallet_addresses,
+                limit: params.limit || 50
+            },
+            headers: {
+                "x-secret-key": THIRDWEB_SECRET_KEY,
+                "x-client-id": THIRDWEB_CLIENT_ID,
+                "x-bundle-id": CLIENT_APP_BUNDLE_ID
+            }
+        };
+        const response = await getV1Nfts(options);
+        if (!response.data) {
+            throw new Error("No data returned from ThirdWeb API");
+        }
+        let transformedResponse = null;
+        // Transform response
+        try {
+            transformedResponse = transformNFTResponse(response.data.data);
+        }
+        catch (error) {
+            console.error("@@insightsMigrate:error", error);
+        }
+        return transformedResponse;
+    }
+    // Migrate Collection Data
+    if (route.startsWith("/v0/nfts/collections/")) {
+        // Extract chain and contract address from route
+        const [chain, contractAddress] = route.split("/").slice(-2);
+        // Validate chain and contract address
+        const chainId = simpleHashChainToChainId(chain);
+        if (!chainId || !contractAddress) {
+            throw new Error("Invalid chain or contract address");
+        }
+        try {
+            const options = {
+                path: {
+                    contract_address: contractAddress
+                },
+                query: {
+                    chain: [chainId]
+                }
+            };
+            const thirdwebResponse = await getV1NftsByContractAddress(options);
+            if (!thirdwebResponse.data?.data?.length) {
+                throw new Error("No data returned from ThirdWeb API", { cause: thirdwebResponse.error });
+            }
+            const transformedResponse = transformCollectionResponse(thirdwebResponse.data.data[0], chainId, chain, contractAddress);
+            return transformedResponse;
+        }
+        catch (error) {
+            console.error("Failed to fetch collection data:", error);
+            throw error;
+        }
+    }
+    // Migrate NFT Transfers
+    if (route.startsWith("/v0/nfts/transfers/")) {
+        // Extract chain and contract address from route
+        const [chain, contractAddress] = route.split("/").slice(-2);
+        // Validate chain and contract address
+        const chainId = simpleHashChainToChainId(chain);
+        if (!chainId || !contractAddress) {
+            throw new Error("Invalid chain or contract address");
+        }
+        try {
+            const options = {
+                path: {
+                    contract_address: contractAddress
+                },
+                query: {
+                    chain: [chainId],
+                    limit: params.limit ? parseInt(params.limit) : 50,
+                    metadata: params.include_nft_details === "1" ? "true" : "false",
+                    sort_by: "block_timestamp",
+                    sort_order: params.order_by?.includes("desc") ? "desc" : "asc",
+                    page: params.page ? parseInt(params.page) : undefined
+                }
+            };
+            const response = await getV1NftsTransfersByContractAddress(options);
+            if (!response.data?.data) {
+                throw new Error("No data returned from ThirdWeb API");
+            }
+            return {
+                transfers: transformTransferResponse(response.data)
+            };
+        }
+        catch (error) {
+            console.error("Failed to fetch transfer data:", error);
+            throw error;
+        }
+    }
+    // Migrate NFT Details
+    if (route.match(/^\/v0\/nfts\/[^/]+\/[^/]+\/[^/]+$/)) {
+        // Extract chain, contract address, and token ID from route
+        const [chain, contractAddress, tokenId] = route.split("/").slice(-3);
+        // Validate chain and contract address
+        const chainId = simpleHashChainToChainId(chain);
+        if (!chainId || !contractAddress || !tokenId) {
+            throw new Error("Invalid chain, contract address, or token ID");
+        }
+        try {
+            const options = {
+                path: {
+                    contract_address: contractAddress,
+                    token_id: tokenId
+                },
+                query: {
+                    chain: [chainId],
+                    include_owners: "true",
+                    resolve_metadata_links: "true"
+                }
+            };
+            const response = await getV1NftsByContractAddressByTokenId(options);
+            if (!response.data?.data?.[0]) {
+                throw new Error("No data returned from ThirdWeb API");
+            }
+            const transformedResponse = transformNFTResponse([
+                {
+                    ...response.data.data[0],
+                    // Needed, because Thirdweb doesn't return the token_id in the response
+                    token_id: tokenId
+                }
+            ]);
+            if (!transformedResponse.nfts?.[0]) {
+                throw new Error("Failed to transform NFT data");
+            }
+            return transformedResponse.nfts[0];
+        }
+        catch (error) {
+            console.error("Failed to fetch NFT details:", error);
+            throw error;
+        }
+    }
+    /**
+     * From here below is the original SimpleHash API code
+     */
+    let url;
+    let options;
+    const cleanParams = Object.fromEntries(Object.entries(params).filter(([_, value]) => value !== undefined && value !== null));
+    if ((isServer || process.env.NEXT_PUBLIC_SERVICE === "backend") && process.env.SIMPLEHASH_API_KEY) {
+        // Server-side request - direct to SimpleHash API
+        url = `https://api.simplehash.com/api${route}`;
+        const queryParams = new URLSearchParams(cleanParams);
+        url += `?${queryParams.toString()}`;
+        options = {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                "X-API-KEY": process.env.SIMPLEHASH_API_KEY
+            }
+        };
+    }
+    else {
+        // Client-side request - use proxy
+        url = `https://simplehash.basement.fun?route=${encodeURIComponent(route)}`;
+        // Append query params
+        Object.keys(cleanParams).forEach(key => {
+            const value = encodeURIComponent(cleanParams[key]);
+            url += `&${key}=${value}`;
+        });
+        const devmodeSharedSecret = process.env.NEXT_PUBLIC_DEVMODE_SHARED_SECRET || process.env.EXPO_PUBLIC_DEVMODE_SHARED_SECRET;
+        // Add devmode shared secret if available
+        if (devmodeSharedSecret) {
+            url += `&localkey=${encodeURIComponent(devmodeSharedSecret)}`;
+        }
+        options = {
+            method: "GET",
+            headers: {
+                accept: "application/json"
+            }
+        };
+    }
+    try {
+        const optionsWithNextOptions = { ...options, ...fetchOptions };
+        const response = await fetch(url, optionsWithNextOptions);
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(`HTTP error! status: ${route} ${response.status} - ${JSON.stringify(errorData)}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (err) {
+        console.error(`Failed to fetch SimpleHash data: ${route}`, err);
+        if (err instanceof Error && err.message.includes("HTTP error!")) {
+            // Error response was already logged above
+            throw err;
+        }
+        // For other errors like network issues
+        console.log("error", err);
+        throw err;
+    }
+}
+export async function fetchFungibleAssets(fungibleIds, includePrices = true) {
+    const route = "/v0/fungibles/assets";
+    const params = {
+        fungible_ids: fungibleIds.join(","),
+        include_prices: includePrices ? "1" : "0"
+    };
+    const response = await fetchSimpleHashData(route, params);
+    if ("fungibles" in response && Array.isArray(response.fungibles)) {
+        return response.fungibles;
+    }
+    else {
+        return response;
+    }
+}
+export async function fetchNativeTokenBalances(chains, walletAddresses) {
+    // Input validation
+    if (!chains?.length || !walletAddresses?.length) {
+        throw new Error("Both chains and walletAddresses arrays must be non-empty");
+    }
+    if (!chains.every(chain => typeof chain === "string") || !walletAddresses.every(addr => typeof addr === "string")) {
+        throw new Error("All chains and wallet addresses must be strings");
+    }
+    const route = "/v0/native_tokens/balances";
+    const params = {
+        chains: chains.join(","),
+        wallet_addresses: walletAddresses.join(",")
+    };
+    try {
+        const response = await fetchSimpleHashData(route, params);
+        if (!response?.native_tokens) {
+            throw new Error("Invalid response format: missing native_tokens field");
+        }
+        return response.native_tokens;
+    }
+    catch (error) {
+        console.error("Failed to fetch native token balances:", {
+            error,
+            chains,
+            walletAddresses
+        });
+        // Rethrow with more context
+        if (error instanceof Error) {
+            throw new Error(`SimpleHash native token balance fetch failed: ${error.message}`);
+        }
+        throw error;
+    }
+}
+export default fetchSimpleHashData;

package/dist/esm/shared/utils/sprinter.d.ts

@@ -0,0 +1 @@
+export declare const getSprinterBaseUrl: (test?: boolean) => string;

package/dist/esm/shared/utils/sprinter.js

@@ -0,0 +1,11 @@
+// import useStore from "./store"
+// // Subscribe to the store to listen for changes
+// let currentSprinterTestnet = useStore.getState().sprinterTestnet;
+// useStore.subscribe((state) => {
+//   currentSprinterTestnet = state.sprinterTestnet;
+// });
+let currentSprinterTestnet = false;
+export const getSprinterBaseUrl = (test) => {
+    const isTestnet = test || currentSprinterTestnet;
+    return `https://api.${isTestnet ? "test." : ""}sprinter.buildwithsygma.com`;
+};

package/dist/esm/shared/utils/thirdweb-insights.d.ts

@@ -0,0 +1,105 @@
+export interface TokenData {
+    chain_id?: number;
+    token_address?: string;
+    contract_address?: string;
+    name?: string;
+    symbol?: string;
+    decimals?: number;
+    balance?: string;
+    description?: string;
+    image_url?: string;
+    video_url?: string;
+    animation_url?: string;
+    background_color?: string;
+    external_url?: string;
+    status?: string;
+    owner_addresses?: string[];
+    token_id?: string;
+    collection?: {
+        name?: string;
+        description?: string;
+        image_url?: string;
+        banner_image_url?: string;
+        featured_image_url?: string;
+        external_link?: string;
+        extra_metadata?: {
+            image_original_url?: string;
+            [key: string]: any;
+        };
+    };
+    contract?: {
+        type?: "ERC20" | "ERC721" | "ERC1155" | "erc20" | "erc721" | "erc1155";
+        name?: string;
+        symbol?: string;
+    };
+    extra_metadata?: {
+        image_original_url?: string;
+        metadata_original_url?: string;
+        attributes?: Array<{
+            trait_type?: string;
+            value?: string | number;
+            display_type?: string;
+        }>;
+        properties?: Record<string, any>;
+        [key: string]: any;
+    };
+    metadata_url?: string;
+    metadata?: {
+        name?: string;
+        description?: string;
+        image?: string;
+        [key: string]: any;
+    };
+}
+export interface TokenBalancesResponse {
+    data: TokenData[];
+    continuation?: string;
+}
+export interface TokenBalancesOptions {
+    chainIds?: number[];
+    tokenType?: "erc20" | "erc721" | "erc1155";
+    limit?: number;
+    continuation?: string;
+    metadata?: boolean;
+    page?: number;
+    includeSpam?: boolean;
+}
+export interface NFTsByContractResponse {
+    data: TokenData[];
+    meta: {
+        chain_id: number;
+        address: string;
+        page: number;
+        limit: number;
+        total_items: number;
+        total_pages: number;
+    };
+}
+export interface NFTsByContractOptions {
+    limit?: number;
+    page?: number;
+}
+export interface FungibleAssetByContractOptions {
+    limit?: number;
+    page?: number;
+    fungibleId?: string;
+}
+export declare function getTokenBalances(ownerAddress: string, options?: TokenBalancesOptions): Promise<TokenBalancesResponse>;
+export declare function getERC20Balances(ownerAddress: string, options?: Omit<TokenBalancesOptions, "tokenType">): Promise<TokenBalancesResponse>;
+export declare function getNFTBalances(ownerAddress: string, options?: Omit<TokenBalancesOptions, "tokenType">): Promise<TokenBalancesResponse>;
+/**
+ * Fetches NFTs for a specific contract address
+ * @param chainId The chain ID where the contract is deployed
+ * @param contractAddress The NFT contract address
+ * @param options Additional options for the request
+ * @returns NFT data for the specified contract
+ */
+export declare function getNFTsByContract(chainId: number, contractAddress: string, options?: NFTsByContractOptions): Promise<NFTsByContractResponse>;
+export declare function getFungibleAssetByContract(chainId: number, contractAddress: string, options?: FungibleAssetByContractOptions): Promise<TokenData>;
+/**
+ * Gets native token balance for a specific chain
+ * @param address Wallet address
+ * @param chainId Chain ID to get native balance for
+ * @returns Native token balance data or null if error
+ */
+export declare function getNativeTokenBalance(address: string, chainId: number): Promise<TokenData | null>;

package/dist/esm/shared/utils/thirdweb-insights.js

@@ -0,0 +1,192 @@
+import { defineChain } from "thirdweb";
+import { getWalletBalance } from "thirdweb/wallets";
+import { supportedChainNetworks } from "../constants/chains/supported";
+import { client } from "./thirdweb";
+const INSIGHTS_BASE_URL = "https://insight.thirdweb.com/v1";
+export async function getTokenBalances(ownerAddress, options = {}) {
+    const { chainIds, tokenType, limit = 100, continuation, metadata = true, page = 0, includeSpam = false } = options;
+    const queryParams = new URLSearchParams();
+    // Add chain parameters for each chainId
+    if (chainIds?.length) {
+        chainIds.forEach(chainId => {
+            queryParams.append("chain", chainId.toString());
+        });
+    }
+    if (limit !== undefined) {
+        queryParams.append("limit", limit.toString());
+    }
+    if (continuation !== undefined) {
+        queryParams.append("continuation", continuation);
+    }
+    if (metadata !== undefined) {
+        queryParams.append("metadata", metadata.toString());
+    }
+    if (page !== undefined) {
+        queryParams.append("page", page.toString());
+    }
+    if (includeSpam !== undefined) {
+        queryParams.append("include_spam", includeSpam.toString());
+    }
+    // Add clientId to query parameters
+    if (client.clientId !== undefined) {
+        queryParams.append("clientId", client.clientId);
+    }
+    // Construct the endpoint based on token type
+    let endpoint;
+    if (tokenType) {
+        endpoint = `/tokens/${tokenType}/${ownerAddress}`;
+    }
+    else {
+        endpoint = `/tokens/${ownerAddress}`;
+    }
+    const url = `${INSIGHTS_BASE_URL}${endpoint}?${queryParams.toString()}`;
+    const response = await fetch(url, {
+        headers: {
+            ...(client.clientId ? { "x-client-id": client.clientId } : {}),
+            ...(client.secretKey ? { "x-secret-key": client.secretKey } : {})
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch token balances: ${response.statusText}`);
+    }
+    return response.json();
+}
+// Function to get ERC20 token balances
+export async function getERC20Balances(ownerAddress, options = {}) {
+    return getTokenBalances(ownerAddress, { ...options, tokenType: "erc20" });
+}
+// Function to get NFT balances (ERC721 and ERC1155)
+export async function getNFTBalances(ownerAddress, options = {}) {
+    const erc721Response = await getTokenBalances(ownerAddress, {
+        ...options,
+        tokenType: "erc721"
+    });
+    const erc1155Response = await getTokenBalances(ownerAddress, {
+        ...options,
+        tokenType: "erc1155"
+    });
+    return {
+        data: [...erc721Response.data, ...erc1155Response.data],
+        continuation: erc1155Response.continuation
+    };
+}
+/**
+ * Fetches NFTs for a specific contract address
+ * @param chainId The chain ID where the contract is deployed
+ * @param contractAddress The NFT contract address
+ * @param options Additional options for the request
+ * @returns NFT data for the specified contract
+ */
+export async function getNFTsByContract(chainId, contractAddress, options = {}) {
+    const { limit = 20, page = 0 } = options;
+    const queryParams = new URLSearchParams();
+    queryParams.append("chain", chainId.toString());
+    if (limit) {
+        queryParams.append("limit", limit.toString());
+    }
+    if (page !== undefined) {
+        queryParams.append("page", page.toString());
+    }
+    // Add clientId to query parameters
+    if (client.clientId) {
+        queryParams.append("clientId", client.clientId);
+    }
+    const endpoint = `/nfts/${contractAddress}/1`;
+    const url = `${INSIGHTS_BASE_URL}${endpoint}?${queryParams.toString()}`;
+    const response = await fetch(url, {
+        headers: {
+            ...(client.clientId ? { "x-client-id": client.clientId } : {}),
+            ...(client.secretKey ? { "x-secret-key": client.secretKey } : {}),
+            "x-chain-id": chainId.toString()
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch NFTs by contract: ${response.statusText}`);
+    }
+    return response.json();
+}
+// This function replaces the simplehash fungible/assets function just in one place - EditGameTOken
+//  I'm not sure if that's the best way to do it, maybe wait for thirdweb to provide a multi id endpoint
+export async function getFungibleAssetByContract(chainId, contractAddress, options = {}) {
+    const { limit = 20, page = 0, fungibleId = 0 } = options;
+    const queryParams = new URLSearchParams();
+    queryParams.append("chain", chainId.toString());
+    if (limit) {
+        queryParams.append("limit", limit.toString());
+    }
+    if (page !== undefined) {
+        queryParams.append("page", page.toString());
+    }
+    // Add clientId to query parameters
+    if (client.clientId) {
+        queryParams.append("clientId", client.clientId);
+    }
+    const endpoint = `/nfts/${contractAddress}/${fungibleId}`;
+    const url = `${INSIGHTS_BASE_URL}${endpoint}?${queryParams.toString()}`;
+    const response = await fetch(url, {
+        headers: {
+            ...(client.clientId ? { "x-client-id": client.clientId } : {}),
+            ...(client.secretKey ? { "x-secret-key": client.secretKey } : {}),
+            "x-chain-id": chainId.toString()
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch NFTs by contract: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.data?.[0] || null;
+}
+/**
+ * Gets native token balance for a specific chain
+ * @param address Wallet address
+ * @param chainId Chain ID to get native balance for
+ * @returns Native token balance data or null if error
+ */
+export async function getNativeTokenBalance(address, chainId) {
+    if (!address) {
+        return null;
+    }
+    try {
+        // Find chain info from supported chains
+        const chainInfo = supportedChainNetworks.find(chain => chain.id === chainId);
+        // Create a chain object from the chainId
+        const chain = defineChain({
+            id: chainId,
+            name: chainInfo?.name || `Chain ${chainId}`,
+            rpc: "",
+            nativeCurrency: {
+                name: chainInfo?.nativeCurrency?.name || "Native Currency",
+                symbol: chainInfo?.nativeCurrency?.symbol || "ETH",
+                decimals: chainInfo?.nativeCurrency?.decimals || 18
+            }
+        });
+        // Get native token balance
+        const balance = await getWalletBalance({
+            address,
+            client,
+            chain
+        });
+        // Format to match TokenData structure
+        return {
+            chain_id: chainId,
+            token_address: "0x0000000000000000000000000000000000000000",
+            contract_address: "0x0000000000000000000000000000000000000000",
+            name: balance.name,
+            symbol: balance.symbol,
+            decimals: balance.decimals,
+            balance: balance.value.toString(),
+            metadata: {
+                logoURI: chainInfo?.icon?.url ||
+                    "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/info/logo.png"
+            },
+            // Add native token info in extra_metadata
+            extra_metadata: {
+                is_native: true
+            }
+        };
+    }
+    catch (error) {
+        console.error(`Error fetching native balance for chain ${chainId}:`, error);
+        return null;
+    }
+}

package/dist/esm/shared/utils/thirdweb.d.ts

@@ -0,0 +1 @@
+export declare const client: import("thirdweb").ThirdwebClient;

package/dist/esm/shared/utils/thirdweb.js

@@ -0,0 +1,8 @@
+import { createThirdwebClient } from "thirdweb";
+import { THIRDWEB_CLIENT_ID, THIRDWEB_SECRET_KEY } from "../constants";
+const clientId = THIRDWEB_CLIENT_ID;
+const secretKey = THIRDWEB_SECRET_KEY;
+if (!clientId && !secretKey) {
+    throw new Error("Either NEXT_PUBLIC_THIRDWEB_CLIENT_ID or THIRDWEB_SECRET_KEY must be provided");
+}
+export const client = createThirdwebClient({ clientId, secretKey });

package/dist/esm/styles/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview CSS Styles Entry Point for @b3dotfun/sdk
+ *
+ * This file serves as the TypeScript entry point for importing the SDK's CSS styles.
+ * It enables consumers to import styles using: `import "../styles"`
+ *
+ * @example
+ * ```typescript
+ * // In your app's main file:
+ * import "../styles";
+ * ```
+ *
+ * Technical Notes:
+ * - This is a side-effect import that loads CSS into the page
+ * - The TypeScript file is required for proper module resolution in monorepos
+ * - The actual CSS is processed by the build system (PostCSS) and output to dist/styles/
+ * - Contains B3 design system variables, fonts, and component styles
+ */
+import "./index.css";
+export {};

package/dist/esm/styles/index.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview CSS Styles Entry Point for @b3dotfun/sdk
+ *
+ * This file serves as the TypeScript entry point for importing the SDK's CSS styles.
+ * It enables consumers to import styles using: `import "../styles"`
+ *
+ * @example
+ * ```typescript
+ * // In your app's main file:
+ * import "../styles";
+ * ```
+ *
+ * Technical Notes:
+ * - This is a side-effect import that loads CSS into the page
+ * - The TypeScript file is required for proper module resolution in monorepos
+ * - The actual CSS is processed by the build system (PostCSS) and output to dist/styles/
+ * - Contains B3 design system variables, fonts, and component styles
+ */
+// Side-effect import of the main CSS file
+import "./index.css";