superstack-wallet-sdk 0.4.2

package/dist/esm/types/LoginModal.styles.d.ts

@@ -0,0 +1,29 @@
+export declare const ModalOverlay: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ModalContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ModalHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ModalTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
+export declare const CloseButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const CloseIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").SVGProps<SVGSVGElement>, never>> & string;
+export declare const LoadingContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const LoadingSpinner: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const LoadingText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>> & string;
+export declare const FormContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const InputField: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, Omit<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & {
+    ref?: ((instance: HTMLInputElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLInputElement> | null | undefined;
+}>, never>, never>> & string;
+export declare const Button: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const DividerContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DividerLine: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DividerText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const DividerBorder: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const SocialButtons: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const SocialButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const SocialIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const VerificationContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const VerificationTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
+export declare const VerificationSubtitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>> & string;
+export declare const CodeInputs: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CodeInputWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CodeInput: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
+export declare const BackButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const FooterText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>> & string;

package/dist/esm/types/adapters/phantom.d.ts

@@ -0,0 +1,30 @@
+import type { SendTransactionOptions, WalletName } from '@solana/wallet-adapter-base';
+import { BaseMessageSignerWalletAdapter, WalletReadyState } from '@solana/wallet-adapter-base';
+import type { Connection, Transaction, TransactionSignature, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { PublicKey } from '@solana/web3.js';
+export interface PhantomWalletAdapterConfig {
+}
+export declare const PhantomWalletName: WalletName<"Phantom">;
+export declare class PhantomWalletAdapter extends BaseMessageSignerWalletAdapter {
+    name: WalletName<"Phantom">;
+    url: string;
+    icon: string;
+    supportedTransactionVersions: ReadonlySet<TransactionVersion>;
+    private _connecting;
+    private _wallet;
+    private _publicKey;
+    private _readyState;
+    constructor(config?: PhantomWalletAdapterConfig);
+    get publicKey(): PublicKey | null;
+    get connecting(): boolean;
+    get readyState(): WalletReadyState;
+    autoConnect(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, connection: Connection, options?: SendTransactionOptions): Promise<TransactionSignature>;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    private _disconnected;
+    private _accountChanged;
+}

package/dist/esm/types/client.d.ts

@@ -0,0 +1,170 @@
+import { Wallet, Social, WalletInfo, Network, IModalManager, MiddleAccountRequest, MiddleAccount, CoinbaseOnrampRequest, OrderState, LoginType } from "./types";
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+import { PhantomWalletAdapter } from "./adapters/phantom";
+import * as viem from "viem";
+interface SolanaCluster {
+    name?: "mainnet-beta" | "devnet" | "testnet";
+    rpcUrl: string;
+}
+interface EthereumNetwork {
+    name?: string;
+    chainId: number;
+    rpcUrl: string;
+}
+export interface WalletProviderConfig {
+    baseURL: string;
+    solanaCluster: SolanaCluster;
+    middleAccountBaseURL?: string;
+    ethereumNetwork?: EthereumNetwork;
+    defaultNetwork?: Network;
+    modalManager?: IModalManager;
+    enableEmail?: boolean;
+    enablePhone?: boolean;
+    enableGoogle?: boolean;
+    enableTwitter?: boolean;
+    enablePhantom?: boolean;
+}
+export declare class WalletClient {
+    private api;
+    private middleAccountApi;
+    private selectedWalletId;
+    private solanaConnection;
+    private ethereumProvider;
+    private walletInfo;
+    private phantomAdapter;
+    private walletType;
+    private solanaCluster;
+    private ethereumNetwork;
+    private defaultNetwork;
+    constructor(config: WalletProviderConfig);
+    private setWallet;
+    private setWalletType;
+    getWallet(): WalletInfo | null;
+    getPhantomAdapter(): PhantomWalletAdapter | null;
+    getWalletType(): "phantom" | "embedded";
+    get wallet(): Wallet | null;
+    get address(): string | null;
+    get network(): Network | null;
+    get ethereumWallet(): Wallet | null;
+    get ethereumAddress(): string | null;
+    get solanaWallet(): Wallet | null;
+    get forwardSolanaWallet(): Wallet | null;
+    get forwardSolanaAddress(): string | null;
+    get forwardEthereumWallet(): Wallet | null;
+    get forwardEthereumAddress(): string | null;
+    get solanaAddress(): string | null;
+    get id(): string | null;
+    get social_links(): Social[] | null;
+    reconnect(): Promise<WalletInfo | null>;
+    connectPhantom(): Promise<WalletInfo | null>;
+    updateAccountName(name: string): Promise<any>;
+    signSolanaTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    signEthereumEip712(params: {
+        domain: {
+            name: string;
+            version: string;
+            chainId: number;
+            verifyingContract: `0x${string}`;
+        };
+        types: Record<string, Array<{
+            name: string;
+            type: string;
+        }>>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<string>;
+    sendSolanaTransaction(transaction: Uint8Array): Promise<string>;
+    sendEthereumTransaction(signedTransaction: string): Promise<string>;
+    sendEmailVerificationCode(email: string): Promise<void>;
+    sendPhoneVerificationCode(phone: string): Promise<void>;
+    verifyEmailVerificationCode({ email, code, }: {
+        email: string;
+        code: string;
+    }): Promise<WalletInfo | null>;
+    verifyPhoneVerificationCode({ phone, code, }: {
+        phone: string;
+        code: string;
+    }): Promise<WalletInfo | null>;
+    twitterLogin(params: {
+        code: string;
+        redirect_uri: string;
+        code_verifier: string | null;
+    }): Promise<WalletInfo | null>;
+    googleLogin(params: {
+        code: string;
+        redirect_uri: string;
+    }): Promise<WalletInfo | null>;
+    oauthLogin(type: LoginType, params: {
+        state: string;
+        code: string;
+        code_verifier: string;
+        network?: Network;
+    }): Promise<WalletInfo | null>;
+    loginWithChallenge(type: LoginType, params: {
+        wallet_address: string;
+        challenge: string;
+        signature: string;
+        network?: Network;
+    }): Promise<WalletInfo | null>;
+    oauthInit(params: {
+        provider: string;
+        redirect_uri: string;
+        state: string;
+        code_challenge: string;
+    }): Promise<{
+        url: string;
+        client_id: string;
+    }>;
+    getSignChallenge(params: {
+        method: "phantom" | "metamask";
+        id: string;
+    }): Promise<{
+        challenge: string;
+        nonce: string;
+        expires_at: number;
+    }>;
+    getSession(): Promise<WalletInfo>;
+    logout(): Promise<void>;
+    getOAuth2ClientId(provider: string): Promise<string>;
+    setSelectedWallet(walletId: string): void;
+    getSelectedWallet(): string | null;
+    getSolanaBalance(): Promise<string>;
+    getEthereumBalance(): Promise<string>;
+    fetchCoinbaseToken(address: string, blockchain?: "solana" | "ethereum"): Promise<string>;
+    viemSignerAdapter(): {
+        signTypedData: (params: {
+            domain: {
+                name: string;
+                version: string;
+                chainId: number;
+                verifyingContract: `0x${string}`;
+            };
+            types: Record<string, Array<{
+                name: string;
+                type: string;
+            }>>;
+            primaryType: string;
+            message: Record<string, unknown>;
+        }) => Promise<`0x${string}`>;
+    };
+    /**
+     * create middle account for middle account flow
+     * @param request request for middle account
+     * @returns middle account info
+     */
+    createMiddleAccount(request: MiddleAccountRequest): Promise<MiddleAccount>;
+    /**
+     * get Coinbase Onramp URL for middle account
+     * @param request request for coinbase onramp
+     * @returns Coinbase Onramp URL
+     */
+    getCoinbaseOnrampUrlForMiddleAccount(request: CoinbaseOnrampRequest): Promise<string>;
+    /**
+     * get order status by orderId
+     * @param orderId orderId
+     * @returns order status
+     */
+    getOrderState(orderId: string): Promise<OrderState>;
+}
+export type SignTransactionReturnType<serializer extends viem.SerializeTransactionFn<viem.TransactionSerializable> = viem.SerializeTransactionFn<viem.TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]> = viem.TransactionSerialized<viem.GetTransactionType<transaction>>;
+export {};

package/dist/esm/types/coinbase.d.ts

@@ -0,0 +1,3 @@
+export declare function useCoinbaseOnramp(): {
+    getCoinbaseOnrampUrl: (amount: number, blockchain?: "solana" | "ethereum", redirectUrl?: string) => Promise<string>;
+};

package/dist/esm/types/context.d.ts

@@ -0,0 +1,28 @@
+import React, { type ReactNode } from "react";
+import { WalletInfo, UserSession } from "./types";
+import { WalletClient, WalletProviderConfig } from "./client";
+interface WalletState {
+    isAuthenticated: boolean;
+    isConnecting: boolean;
+    isInitialized: boolean;
+    walletInfo: WalletInfo | null;
+    wallet: WalletClient | null;
+    session: UserSession | null;
+    error: string | null;
+    enableEmail: boolean;
+    enablePhone: boolean;
+    enableGoogle: boolean;
+    enableTwitter: boolean;
+    enablePhantom: boolean;
+}
+interface WalletContextValue extends WalletState {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+}
+interface WalletProviderProps {
+    children: ReactNode;
+    config: WalletProviderConfig;
+}
+export declare function WalletProvider({ children, config }: WalletProviderProps): React.JSX.Element;
+export declare function useWallet(): WalletContextValue;
+export {};

package/dist/esm/types/hooks.d.ts

@@ -0,0 +1,56 @@
+import { LoginModalProps, LoginType } from "./types";
+export declare function useConnect(): {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    isConnecting: boolean;
+};
+export declare function useWalletStatus(): {
+    isAuthenticated: boolean;
+    authenticated: boolean;
+    error: string | null;
+    session: import("./types").UserSession | null;
+    isInitialized: boolean;
+    ready: boolean;
+};
+export declare function useActiveWallet(): {
+    wallet: import("./client").WalletClient | null;
+};
+export declare function useLoginModal({ client, isOpen, onClose, onLogin, isLoading, }: LoginModalProps): {
+    email: string;
+    setEmail: import("react").Dispatch<import("react").SetStateAction<string>>;
+    emailSent: boolean;
+    setEmailSent: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    sendingCode: boolean;
+    setVerificationCode: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    verificationCode: string[];
+    verifyingCode: boolean;
+    connectingPhantom: boolean;
+    inputRefs: import("react").RefObject<HTMLInputElement>[];
+    handleCodeChange: (index: number, value: string) => void;
+    handleKeyDown: (index: number, e: React.KeyboardEvent) => void;
+    handleContainerPaste: (e: React.ClipboardEvent) => void;
+    handleSendVerificationCode: (emailInput?: string) => Promise<void>;
+    handleCodeSubmit: (code?: string, emailInput?: string) => Promise<void>;
+    handlePhoneCodeSubmit: (code?: string, phoneInput?: string) => Promise<void>;
+    handleSendPhoneVerificationCode: (phoneInput?: string) => Promise<void>;
+    handleGetChallenge: (address: string) => Promise<{
+        challenge: string;
+        nonce: string;
+        expires_at: number;
+    }>;
+    handleLoginWithChallenge: (type: LoginType, params: {
+        wallet_address: string;
+        challenge: string;
+        signature: string;
+    }) => Promise<void>;
+    phone: string;
+    setPhone: import("react").Dispatch<import("react").SetStateAction<string>>;
+    phoneSent: boolean;
+    setPhoneSent: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    onOauthLogin: (type: "google" | "twitter") => Promise<void>;
+    handlePhantomLogin: () => Promise<void>;
+    isOpen: boolean;
+    onClose: () => void;
+    onLogin: ((walletInfo: import("./types").WalletInfo) => void) | undefined;
+    isLoading: boolean;
+};

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

@@ -0,0 +1,8 @@
+import "./polyfills";
+export * from "./client";
+export * from "./context";
+export * from "./hooks";
+export * from "./storage";
+export * from "./types";
+export * from "./styles";
+export * from "./coinbase";

package/dist/esm/types/modal.d.ts

@@ -0,0 +1,20 @@
+import { WalletInfo, IModalManager } from "./types";
+import { WalletClient } from "./client";
+export declare class ModalManager implements IModalManager {
+    private container;
+    private root;
+    private createContainer;
+    private removeExistingContainer;
+    showLoginModal({ client, isLoading, onClose, onLogin, enableEmail, enablePhone, enableGoogle, enableTwitter, enablePhantom, }: {
+        client: WalletClient;
+        isLoading?: boolean;
+        onClose?: () => void;
+        onLogin?: (walletInfo: WalletInfo) => void;
+        enableEmail?: boolean;
+        enablePhone?: boolean;
+        enableGoogle?: boolean;
+        enableTwitter?: boolean;
+        enablePhantom?: boolean;
+    }): Promise<void>;
+    hideModal(): void;
+}

package/dist/esm/types/polyfills.d.ts

@@ -0,0 +1 @@
+export declare function ensurePolyfills(): boolean;

package/dist/esm/types/storage.d.ts

@@ -0,0 +1,9 @@
+import { Social } from "./types";
+export declare class Storage {
+    static saveAccessToken(token: string, social: Social): void;
+    static saveWalletType(type: "phantom" | "embedded"): void;
+    static getWalletType(): "phantom" | "embedded" | null;
+    static getAccessToken(): string | null;
+    static getSocial(): Social | null;
+    static clear(): void;
+}

package/dist/esm/types/styles/globalStyles.d.ts

@@ -0,0 +1,2 @@
+declare const GlobalStyles: import("react").NamedExoticComponent<import("styled-components").ExecutionProps & object>;
+export default GlobalStyles;

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

@@ -0,0 +1,2 @@
+export { theme } from "./theme";
+export declare const injectStyles: () => void;

package/dist/esm/types/styles/theme.d.ts

@@ -0,0 +1,103 @@
+export declare const theme: {
+    colors: {
+        black: string;
+        white: string;
+        offWhite: string;
+        grey: {
+            100: string;
+            200: string;
+            300: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+        };
+        primary: string;
+        secondary: string;
+        error: string;
+        success: string;
+        background: {
+            main: string;
+            secondary: string;
+            overlay: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            inverse: string;
+        };
+        button: {
+            primary: {
+                background: string;
+                text: string;
+                hover: string;
+                disabled: string;
+            };
+            secondary: {
+                background: string;
+                text: string;
+                hover: string;
+                disabled: string;
+            };
+        };
+        border: {
+            light: string;
+            medium: string;
+            dark: string;
+        };
+    };
+    typography: {
+        fontFamily: string;
+        fontSizes: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+            '2xl': string;
+            '3xl': string;
+            '4xl': string;
+        };
+        fontWeights: {
+            light: number;
+            regular: number;
+            medium: number;
+            semibold: number;
+            bold: number;
+        };
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+        '3xl': string;
+    };
+    borderRadius: {
+        none: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+        full: string;
+    };
+    shadows: {
+        none: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    transitions: {
+        fast: string;
+        normal: string;
+        slow: string;
+    };
+};
+export default theme;

package/dist/esm/types/types.d.ts

@@ -0,0 +1,132 @@
+import type { Transaction, TransactionVersion, VersionedTransaction } from "@solana/web3.js";
+import { WalletClient } from "./client";
+export type SupportedTransactionVersions = ReadonlySet<TransactionVersion> | null | undefined;
+export type TransactionOrVersionedTransaction<S extends SupportedTransactionVersions> = S extends null | undefined ? Transaction : Transaction | VersionedTransaction;
+export declare function isVersionedTransaction(transaction: Transaction | VersionedTransaction): transaction is VersionedTransaction;
+export type LoginType = "TwitterOAuth" | "GoogleOAuth" | "Phantom" | "Okx" | "Email" | "Phone" | "Telegram" | "TelegramOAuth";
+export declare enum Network {
+    Solana = "Solana",
+    Ethereum = "Ethereum"
+}
+export declare enum WalletType {
+    Phantom = "Phantom",
+    Embedded = "Embedded"
+}
+export declare enum SocialType {
+    Email = "Email",
+    Google = "Google",
+    Twitter = "Twitter",
+    Phantom = "Phantom",
+    Phone = "Phone",
+    Okx = "Okx"
+}
+export type Social = {
+    [key in SocialType]: string;
+};
+export type SocialInfo = {
+    [key in SocialType]: {
+        id: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        family_name?: string;
+        given_name?: string;
+        picture?: string;
+    };
+};
+export interface Wallet {
+    id: string;
+    address: string;
+    network: Network;
+    wallet_type: WalletType;
+    wallet_set: "Main" | "Forward-0" | string;
+}
+export interface WalletInfo {
+    account_info: AccountInfo;
+    id: string;
+    is_exported: boolean;
+    wallets: Wallet[];
+    social_links: Social[];
+    social_infos: SocialInfo[];
+}
+export interface AccountInfo {
+    name: string | null;
+}
+export interface SignRequestV1 {
+    address: string;
+    userId: string;
+    message: string;
+    network: string;
+    requestId: string;
+}
+export interface UnsignedTx {
+    Solana?: string;
+    EthereumEip712?: Record<string, unknown>;
+}
+export interface SignRequestV2 {
+    address: string;
+    user_id: string;
+    network: string;
+    tx: UnsignedTx;
+}
+export interface UserSession {
+    id: string;
+    userId: string;
+    email: string;
+    name: string;
+}
+export interface SignMessageResponse {
+    signature: string;
+}
+export interface SignTransactionResponse {
+    signature: string;
+}
+export interface ApiResponse<T> {
+    data: T;
+    error?: string;
+}
+export interface LoginModalProps {
+    client: WalletClient;
+    isOpen: boolean;
+    onClose: () => void;
+    onLogin?: (walletInfo: WalletInfo) => void;
+    isLoading?: boolean;
+    type?: SocialType;
+    enableEmail?: boolean;
+    enablePhone?: boolean;
+    enableGoogle?: boolean;
+    enableTwitter?: boolean;
+    enablePhantom?: boolean;
+}
+export interface IModalManager {
+    showLoginModal: (params: {
+        client: WalletClient;
+        isLoading?: boolean;
+        onClose?: () => void;
+        onLogin?: (walletInfo: WalletInfo) => void;
+        enableEmail?: boolean;
+        enablePhone?: boolean;
+        enableGoogle?: boolean;
+        enableTwitter?: boolean;
+        enablePhantom?: boolean;
+    }) => Promise<void>;
+    hideModal: () => void;
+}
+export interface MiddleAccountRequest {
+    order_id: string;
+}
+export interface MiddleAccount {
+    payment_address: string;
+    received: number;
+}
+export interface CoinbaseOnrampRequest {
+    middleAccountAddress: string;
+    amount: number;
+    currency: "USDC" | "SOL";
+    network: Network;
+    redirectUrl?: string;
+}
+export interface OrderState {
+    payment_address: string;
+    received: number;
+}

package/dist/esm/types/utils/coinbaseUtils.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_ONRAMP_URL = "https://pay.coinbase.com";
+/** The base URL for the Coinbase Onramp widget */
+export declare const ONRAMP_BUY_URL = "https://pay.coinbase.com/buy";
+/**
+ * Builds a Coinbase Onramp buy URL using the provided parameters.
+ * @param projectId a projectId generated in the Coinbase Developer Portal
+ * @returns the URL
+ */
+export declare function getOnrampBuyUrl({ projectId, originComponentName, ...props }: Record<any, any>): string;

package/dist/esm/types/utils/oauth.d.ts

@@ -0,0 +1,21 @@
+export declare function buildOAuthState(provider: string): string;
+export declare function buildCodeVerifierAndChallenge(provider: string): Promise<{
+    codeVerifier: string;
+    codeChallenge: string;
+}>;
+export declare function retrieveAndClearCodeVerifierAndChallenge(provider: string): {
+    codeVerifier: string;
+    codeChallenge: string;
+} | null;
+export declare function retrieveAndClearState(provider: string): string | null;
+export interface AuthLinkQueryParams {
+    client_id: string;
+    redirect_uri: string;
+    state: string;
+    code_challenge: string;
+}
+export interface OAuthLinkRes {
+    url: string;
+}
+export declare function getTwitterOAuth2Link(params: AuthLinkQueryParams): Promise<string>;
+export declare function getGoogleOAuth2Link(params: AuthLinkQueryParams): Promise<string>;