@b3dotfun/sdk 0.0.1-alpha.1

package/src/global-account/react/stores/useModalStore.ts

@@ -0,0 +1,325 @@
+import { Token, Tournament } from "@b3dotfun/sdk/anyspend";
+import { NftContract } from "@b3dotfun/sdk/anyspend/types";
+import { AllowedStrategy } from "@b3dotfun/sdk/global-account/react/components/SignInWithB3/utils/signInUtils";
+import { PermissionsConfig } from "@b3dotfun/sdk/global-account/types/permissions";
+import { Address, Chain } from "thirdweb";
+import { Account } from "thirdweb/wallets";
+import { create } from "zustand";
+
+/**
+ * Base modal props that all modal types extend
+ */
+interface BaseModalProps {
+  /** Whether to show a back button in the modal header */
+  showBackButton?: boolean;
+}
+
+/**
+ * Props for the Sign In With B3 modal
+ * Handles authentication flow with various providers
+ */
+export interface SignInWithB3ModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "signInWithB3";
+  /** Authentication provider to use for sign-in */
+  strategies?: AllowedStrategy[];
+  /** Callback function called when login is successful */
+  onLoginSuccess?: (account: Account) => void;
+  /** Callback function called when session key is successfully added */
+  onSessionKeySuccess?: () => void;
+  /** Callback function called when an error occurs */
+  onError?: (error: Error) => Promise<void>;
+  /** Blockchain chain information */
+  chain: Chain;
+  /** Address of the session key, typically the user's login address */
+  sessionKeyAddress?: Address;
+  /** Unique identifier for the partner application */
+  partnerId: string;
+  /** Whether to authenticate with Sign In With Ethereum */
+  loginWithSiwe?: boolean;
+  /** Whether to close the modal after successful login */
+  closeAfterLogin?: boolean;
+  /** Source of the sign-in request */
+  source?: "signInWithB3Button" | "requestPermissions";
+  /** Whether to show the signers enabled modal */
+  signersEnabled?: boolean;
+}
+
+/**
+ * Props for the Request Permissions modal
+ * Used to request permission for session keys to interact with contracts
+ */
+export interface RequestPermissionsModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "requestPermissions";
+  /** Callback function called when permissions are successfully granted */
+  onSuccess?: () => void;
+  /** Callback function called when an error occurs */
+  onError?: (error: Error) => Promise<void>;
+  /** Blockchain chain information */
+  chain?: Chain;
+  /** Address of the session key to grant permissions to */
+  sessionKeyAddress?: Address;
+  /** Permissions to request */
+  permissions?: PermissionsConfig;
+}
+
+/**
+ * Props for the Manage Account modal
+ * Allows users to manage their account settings and actions
+ */
+export interface ManageAccountModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "manageAccount";
+  /** Callback function called when user logs out */
+  onLogout?: () => void;
+  /** Callback function called when user initiates a swap */
+  onSwap?: () => void;
+  /** Callback function called when user initiates a deposit */
+  onDeposit?: () => void;
+  /** Callback function called when user views their profile */
+  onViewProfile?: () => void;
+  /** Blockchain chain information */
+  chain: Chain;
+  /** Partner ID */
+  partnerId: string;
+}
+
+/**
+ * Props for the AnySpend modal
+ * Handles cross-chain token transfers and transactions
+ */
+export interface AnySpendModalProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpend";
+  /** The default active tab */
+  defaultActiveTab?: "crypto" | "fiat";
+  /** Chain ID of the source blockchain */
+  sourceChainId?: number;
+  /** Chain ID of the destination blockchain */
+  destinationChainId?: number;
+  /** Token address or identifier on the source chain */
+  sourceToken?: string;
+  /** Token address or identifier on the destination chain */
+  destinationToken?: string;
+  /** Amount of tokens to send from source chain */
+  sourceAmount?: string;
+  /** Amount of tokens to receive on destination chain */
+  destinationAmount?: string;
+  /** Address to receive the tokens on the destination chain */
+  recipientAddress?: string;
+  /** Unique identifier for an existing order */
+  orderId?: string;
+  /** Whether to hide the transaction history button */
+  hideTransactionHistoryButton?: boolean;
+  /** Callback function called when the transaction is successful */
+  onSuccess?: () => void;
+  /** Token address of the destination token to buy (enables buy mode) */
+  destinationTokenAddress?: string;
+  /** Chain ID where the destination token exists (enables buy mode) */
+  destinationTokenChainId?: number;
+}
+
+/**
+ * Props for the AnySpend NFT modal
+ * Handles NFT-specific operations
+ */
+export interface AnySpendNftProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendNft";
+  /** NFT contract information */
+  nftContract: NftContract;
+  /** Recipient address to receive the NFT */
+  recipientAddress?: string;
+}
+
+/**
+ * Props for the AnySpend tournament modal
+ */
+export interface AnySpendJoinTournamentProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendJoinTournament";
+  /** Recipient address to join the tournament for */
+  joinFor: string;
+  /** Tournament chain ID */
+  tournamentChainId: number;
+  /** Tournament contract address */
+  tournamentContractAddress: string;
+  /** Tournament metadata */
+  tournamentMetadata: Tournament;
+  /** Tournament entry token */
+  tournamentEntryToken: Token;
+  /** Tournament entry fee */
+  tournamentEntryFee: string;
+  /** Callback function called when the tournament is successfully joined */
+  onSuccess?: () => void;
+}
+
+/**
+ * Props for the AnySpend tournament modal
+ */
+export interface AnySpendFundTournamentProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendFundTournament";
+  /** Tournament chain ID */
+  tournamentChainId: number;
+  /** Tournament contract address */
+  tournamentContractAddress: string;
+  /** Tournament metadata */
+  tournamentMetadata: Tournament;
+  /** Tournament fund token */
+  tournamentFundToken: Token;
+  /** Tournament fund amount */
+  tournamentFundAmount: string;
+  /** Callback function called when the tournament is successfully joined */
+  onSuccess?: () => void;
+}
+
+/**
+ * Props for the AnySpend order details modal
+ * Displays details about a specific order
+ */
+export interface AnyspendOrderDetailsProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anyspendOrderDetails";
+  /** Unique identifier for the order to display */
+  orderId: string;
+  /** Whether to show the back button */
+  showBackButton?: boolean;
+}
+
+/**
+ * Props for the Transak modal
+ * Handles Transak-specific on-ramping
+ */
+export interface TransakProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "transak";
+  /** Wallet address to receive the purchased crypto */
+  destinationWalletAddress?: string;
+  /** Default amount of crypto to purchase */
+  defaultCryptoAmount?: number;
+  /** Amount of fiat currency to spend */
+  fiatAmount?: number;
+  /** ISO country code for KYC and available payment methods */
+  countryCode?: string;
+  /** Callback function called when the purchase is successful */
+  onSuccess?: () => void;
+}
+
+/**
+ * Props for the AnySpend order history modal
+ */
+export interface AnySpendOrderHistoryProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendOrderHistory";
+}
+
+/**
+ * Props for the AnySpend Stake B3 modal
+ * Handles B3 token staking operations
+ */
+export interface AnySpendStakeB3Props extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendStakeB3";
+  /** Recipient address to stake B3 for */
+  recipientAddress: string;
+  /** Stake amount */
+  stakeAmount?: string;
+  /** Callback function called when the stake is successful */
+  onSuccess?: () => void;
+}
+
+/**
+ * Props for the AnySpend Buy Spin modal
+ * Handles spin wheel entry purchases
+ */
+export interface AnySpendBuySpinProps extends BaseModalProps {
+  /** Modal type identifier */
+  type: "anySpendBuySpin";
+  /** Spin wheel contract address */
+  spinwheelContractAddress: string;
+  /** Chain ID where the spin wheel contract is deployed */
+  chainId: number;
+  /** Recipient address to receive the spins */
+  recipientAddress: string;
+  /** Callback function called when the spin purchase is successful */
+  onSuccess?: (txHash?: string) => void;
+}
+
+/**
+ * Union type of all possible modal content types
+ */
+export type ModalContentType =
+  | SignInWithB3ModalProps
+  | RequestPermissionsModalProps
+  | ManageAccountModalProps
+  | AnySpendModalProps
+  | AnyspendOrderDetailsProps
+  | AnySpendNftProps
+  | AnySpendJoinTournamentProps
+  | AnySpendFundTournamentProps
+  | TransakProps
+  | AnySpendOrderHistoryProps
+  | AnySpendStakeB3Props
+  | AnySpendBuySpinProps;
+// Add other modal types here like: | OtherModalProps | AnotherModalProps
+
+/**
+ * State interface for the modal store
+ */
+interface ModalState {
+  /** Whether the modal is currently open */
+  isOpen: boolean;
+  /** Current content being displayed in the modal */
+  contentType: ModalContentType | null;
+  /** History of previously displayed modal contents */
+  history: ModalContentType[];
+  /** Function to open or close the modal */
+  setB3ModalOpen: (isOpen: boolean) => void;
+  /** Function to set the modal content and add current content to history */
+  setB3ModalContentType: (content: ModalContentType) => void;
+  /** Function to navigate back to the previous modal content */
+  navigateBack: () => void;
+  /** Function to clear the modal history */
+  clearHistory: () => void;
+  /** Address of the ecosystem account */
+  ecoSystemAccountAddress?: Address;
+  /** Function to set the ecosystem account address */
+  setEcoSystemAccountAddress: (address: Address) => void;
+}
+
+/**
+ * Zustand store for managing modal state
+ * Handles modal visibility, content type, and navigation history
+ */
+export const useModalStore = create<ModalState>(set => ({
+  isOpen: false,
+  contentType: null,
+  history: [],
+  setB3ModalOpen: isOpen => set({ isOpen }),
+  setB3ModalContentType: content =>
+    set(state => {
+      // Add current modal to history before changing
+      const newHistory = state.contentType ? [...state.history, state.contentType] : state.history;
+      return {
+        contentType: content,
+        history: newHistory
+      };
+    }),
+  navigateBack: () =>
+    set(state => {
+      if (state.history.length === 0) {
+        return { isOpen: false, contentType: null };
+      }
+      const newHistory = [...state.history];
+      const previousModal = newHistory.pop();
+      return {
+        contentType: previousModal || null,
+        history: newHistory
+      };
+    }),
+  clearHistory: () => set({ history: [] }),
+  ecoSystemAccountAddress: undefined,
+  setEcoSystemAccountAddress: (address: Address) => set({ ecoSystemAccountAddress: address })
+}));

package/src/global-account/server.ts

@@ -0,0 +1,23 @@
+const B3_API_URL = process.env.NEXT_PUBLIC_B3_API || process.env.PUBLIC_B3_API || "https://api.b3.fun";
+
+/**
+ * Authenticate with the B3 API using the token
+ * Server-side only version that doesn't include socket.io dependencies
+ *
+ * @param token - The token to authenticate with
+ * @returns The response from the B3 API
+ */
+export const authenticateWithRest = async (token: string) => {
+  const response = await fetch(`${B3_API_URL}/authentication`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      strategy: "jwt",
+      accessToken: token
+    })
+  });
+  return response;
+};

package/src/global-account/types/b3-api.ts

@@ -0,0 +1,4 @@
+import * as b3Api from "@b3dotfun/b3-api";
+
+export * from "@b3dotfun/b3-api";
+export default b3Api;

package/src/global-account/types/b3-api.types.ts

@@ -0,0 +1,83 @@
+// TODO: Get this from the B3 API, compiled version
+// For now, we are generating vanilla TS types based on the schema
+
+/**
+ * User-related type definitions
+ */
+
+// MongoDB ObjectId type
+type ObjectId = string;
+
+// Partner IDs interface
+interface PartnerIds {
+  privyId?: string;
+  thirdwebId?: string;
+}
+
+// Privy linked account interface
+interface PrivyLinkedAccount {
+  type: string; // "wallet" | "smart_wallet" | "google_oauth"
+  address?: string;
+  email?: string;
+  lv?: number;
+  wallet_client_type?: string;
+  smart_wallet_type?: string;
+  subject?: string;
+  name?: string;
+}
+
+// Thirdweb profile interface
+interface TWProfile {
+  type: string;
+  details: {
+    id?: string;
+    email?: string;
+    phone?: string;
+    address?: string; // Matches pattern: ^0x[a-fA-F0-9]{40}$
+  };
+}
+
+// User preferences type (extensible object)
+interface UserPreferences {
+  [key: string]: any;
+}
+
+// Main User interface
+interface User {
+  _id: ObjectId;
+  userId: string;
+
+  // Auth identifiers
+  email?: string;
+  telNumber?: string;
+  smartAccountAddress: string; // Pattern: ^0x[a-fA-F0-9]{40}$
+
+  // Core identity
+  username?: string;
+  ens?: string;
+
+  // Metadata
+  avatar?: string;
+  preferences?: UserPreferences;
+
+  // Partner metadata
+  referredBy?: ObjectId;
+  sourceApp?: string;
+
+  // User groups for permissions
+  userGroups?: number[]; // Values 0-10: 0=regular user, 1=admin, 2=moderator, 3=partner
+
+  // Migration
+  isMigratedFromBSMNT?: boolean;
+
+  // Timestamps
+  createdAt: number;
+  updatedAt: number;
+
+  // Partner integrations
+  partnerIds: PartnerIds;
+  privyLinkedAccounts?: PrivyLinkedAccount[];
+  twProfiles?: TWProfile[];
+}
+
+export type { ObjectId, PartnerIds, PrivyLinkedAccount, TWProfile, User, UserPreferences };

package/src/global-account/types/chain-networks.ts

@@ -0,0 +1,54 @@
+import { ObjectIdSchema, Static, Type } from "@feathersjs/typebox";
+
+const ChainContractSchema = Type.Object({
+  address: Type.String(),
+  blockCreated: Type.Optional(Type.Integer())
+});
+
+export const chainNetworksSchema = Type.Object(
+  {
+    _id: ObjectIdSchema(),
+    id: Type.Integer(),
+    name: Type.String(),
+    rpcUrls: Type.Object({
+      default: Type.Object({
+        http: Type.String({ format: "uri" }),
+        ws: Type.String({ format: "uri" })
+      }),
+      backups: Type.Array(
+        Type.Object({
+          type: Type.Union([Type.Literal("http"), Type.Literal("ws")]),
+          uri: Type.String()
+        })
+      )
+    }),
+    icon: Type.Object({
+      url: Type.String({ format: "uri" }),
+      width: Type.Integer(),
+      height: Type.Integer(),
+      format: Type.String()
+    }),
+    blockExplorers: Type.Object({
+      explorerTitle: Type.String(),
+      default: Type.String({ format: "uri" })
+    }),
+    nativeCurrency: Type.Object({
+      name: Type.String(),
+      symbol: Type.String(),
+      decimals: Type.Integer()
+    }),
+    testnet: Type.Optional(Type.Boolean()),
+    testnetConfigID: Type.Optional(Type.Integer()),
+    // Additional required Viem fields that can't be derived
+    sourceId: Type.Optional(Type.Integer()),
+    contracts: Type.Optional(Type.Record(Type.String(), ChainContractSchema)),
+    formatters: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    fees: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    badge: Type.Optional(Type.String({ format: "uri" })),
+    color: Type.Optional(Type.String()),
+    enabledFeatures: Type.Optional(Type.Array(Type.String()))
+  },
+  { $id: "ChainNetworks", additionalProperties: false }
+);
+
+export type ChainNetworks = Static<typeof chainNetworksSchema>;

package/src/global-account/types/feature-flags.ts

@@ -0,0 +1,13 @@
+import { ObjectIdSchema, Static, Type } from "@feathersjs/typebox";
+
+export const featureFlagsSchema = Type.Object(
+  {
+    _id: ObjectIdSchema(),
+    id: Type.String(),
+    enabled: Type.Boolean(),
+    description: Type.String()
+  },
+  { $id: "FeatureFlags", additionalProperties: false }
+);
+
+export type FeatureFlags = Static<typeof featureFlagsSchema>;

package/src/global-account/types/permissions.ts

@@ -0,0 +1,24 @@
+/**
+ * Configuration for user permissions when interacting with contracts
+ */
+export interface PermissionsConfig {
+  /**
+   * List of contract addresses that are approved for interaction
+   */
+  approvedTargets: string[];
+
+  /**
+   * Maximum amount of native tokens (in ETH) allowed per transaction
+   */
+  nativeTokenLimitPerTransaction: number;
+
+  /**
+   * Date when these permissions become valid
+   */
+  startDate: Date;
+
+  /**
+   * Date when these permissions expire
+   */
+  endDate: Date;
+}

package/src/global-account/types/react-timeago.d.ts

@@ -0,0 +1,18 @@
+"use client";
+
+import * as React from "react";
+
+declare module "react-timeago" {
+  export interface TimeAgoProps {
+    date: Date | string | number;
+    formatter?: (value: number, unit: string, suffix: string) => string;
+    component?: string | React.ComponentType<any>;
+    live?: boolean;
+    minPeriod?: number;
+    maxPeriod?: number;
+    title?: string;
+    [key: string]: any;
+  }
+
+  export default class TimeAgo extends React.Component<TimeAgoProps> {}
+}

package/src/global-account/types/reservoir.types.ts

@@ -0,0 +1,94 @@
+export type ReservoirCollectionResponse = {
+  collections: ReservoirCollection[];
+};
+
+export type ReservoirCollection = {
+  chainId: number;
+  id: string;
+  slug: string | null;
+  createdAt: string;
+  updatedAt: string;
+  name: string;
+  symbol: string;
+  contractDeployedAt: string;
+  image: string;
+  banner: string | null;
+  twitterUrl: string | null;
+  discordUrl: string | null;
+  externalUrl: string | null;
+  twitterUsername: string | null;
+  openseaVerificationStatus: string | null;
+  magicedenVerificationStatus: string | null;
+  description: string;
+  metadataDisabled: boolean;
+  isSpam: boolean;
+  isNsfw: boolean;
+  isMinting: boolean;
+  sampleImages: string[];
+  tokenCount: string;
+  onSaleCount: string;
+  primaryContract: string;
+  tokenSetId: string;
+  creator: string;
+  isSharedContract: boolean;
+  royalties:
+    | null
+    | {
+        // Add royalty type if needed
+      };
+  allRoyalties: {
+    eip2981: any[];
+    onchain: any[];
+  };
+  floorAsk: {
+    id: string | null;
+    price: number | null;
+    maker: string | null;
+    validFrom: number;
+    validUntil: number | null;
+    token: any | null;
+  };
+  topBid: {
+    id: string | null;
+    sourceDomain: string | null;
+    price: number | null;
+    maker: string | null;
+    validFrom: string | null;
+    validUntil: string | null;
+  };
+  rank: {
+    "1day": number | null;
+    "7day": number | null;
+    "30day": number | null;
+    allTime: number | null;
+  };
+  volume: {
+    "1day": number;
+    "7day": number;
+    "30day": number;
+    allTime: number;
+  };
+  volumeChange: {
+    "1day": number | null;
+    "7day": number | null;
+    "30day": number | null;
+  };
+  floorSale: {
+    "1day": number | null;
+    "7day": number | null;
+    "30day": number | null;
+  };
+  floorSaleChange: {
+    "1day": number | null;
+    "7day": number | null;
+    "30day": number | null;
+  };
+  collectionBidSupported: boolean;
+  ownerCount: number;
+  contractKind: string;
+  mintedTimestamp: number;
+  lastMintTimestamp: number;
+  mintStages: any[];
+  supply: string;
+  remainingSupply: string;
+};