superstack-wallet-sdk 0.4.2

package/dist/index.d.ts

@@ -0,0 +1,530 @@
+import { TransactionVersion, Transaction, VersionedTransaction, PublicKey, Connection, TransactionSignature } from '@solana/web3.js';
+import { BaseMessageSignerWalletAdapter, WalletName, WalletReadyState, SendTransactionOptions } from '@solana/wallet-adapter-base';
+import * as viem from 'viem';
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+
+type SupportedTransactionVersions = ReadonlySet<TransactionVersion> | null | undefined;
+type TransactionOrVersionedTransaction<S extends SupportedTransactionVersions> = S extends null | undefined ? Transaction : Transaction | VersionedTransaction;
+declare function isVersionedTransaction(transaction: Transaction | VersionedTransaction): transaction is VersionedTransaction;
+type LoginType = "TwitterOAuth" | "GoogleOAuth" | "Phantom" | "Okx" | "Email" | "Phone" | "Telegram" | "TelegramOAuth";
+declare enum Network {
+    Solana = "Solana",
+    Ethereum = "Ethereum"
+}
+declare enum WalletType {
+    Phantom = "Phantom",
+    Embedded = "Embedded"
+}
+declare enum SocialType {
+    Email = "Email",
+    Google = "Google",
+    Twitter = "Twitter",
+    Phantom = "Phantom",
+    Phone = "Phone",
+    Okx = "Okx"
+}
+type Social = {
+    [key in SocialType]: string;
+};
+type SocialInfo = {
+    [key in SocialType]: {
+        id: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+        family_name?: string;
+        given_name?: string;
+        picture?: string;
+    };
+};
+interface Wallet {
+    id: string;
+    address: string;
+    network: Network;
+    wallet_type: WalletType;
+    wallet_set: "Main" | "Forward-0" | string;
+}
+interface WalletInfo {
+    account_info: AccountInfo;
+    id: string;
+    is_exported: boolean;
+    wallets: Wallet[];
+    social_links: Social[];
+    social_infos: SocialInfo[];
+}
+interface AccountInfo {
+    name: string | null;
+}
+interface SignRequestV1 {
+    address: string;
+    userId: string;
+    message: string;
+    network: string;
+    requestId: string;
+}
+interface UnsignedTx {
+    Solana?: string;
+    EthereumEip712?: Record<string, unknown>;
+}
+interface SignRequestV2 {
+    address: string;
+    user_id: string;
+    network: string;
+    tx: UnsignedTx;
+}
+interface UserSession {
+    id: string;
+    userId: string;
+    email: string;
+    name: string;
+}
+interface SignMessageResponse {
+    signature: string;
+}
+interface SignTransactionResponse {
+    signature: string;
+}
+interface ApiResponse<T> {
+    data: T;
+    error?: string;
+}
+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;
+}
+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;
+}
+interface MiddleAccountRequest {
+    order_id: string;
+}
+interface MiddleAccount {
+    payment_address: string;
+    received: number;
+}
+interface CoinbaseOnrampRequest {
+    middleAccountAddress: string;
+    amount: number;
+    currency: "USDC" | "SOL";
+    network: Network;
+    redirectUrl?: string;
+}
+interface OrderState {
+    payment_address: string;
+    received: number;
+}
+
+interface PhantomWalletAdapterConfig {
+}
+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;
+}
+
+interface SolanaCluster {
+    name?: "mainnet-beta" | "devnet" | "testnet";
+    rpcUrl: string;
+}
+interface EthereumNetwork {
+    name?: string;
+    chainId: number;
+    rpcUrl: string;
+}
+interface WalletProviderConfig {
+    baseURL: string;
+    solanaCluster: SolanaCluster;
+    middleAccountBaseURL?: string;
+    ethereumNetwork?: EthereumNetwork;
+    defaultNetwork?: Network;
+    modalManager?: IModalManager;
+    enableEmail?: boolean;
+    enablePhone?: boolean;
+    enableGoogle?: boolean;
+    enableTwitter?: boolean;
+    enablePhantom?: boolean;
+}
+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>;
+}
+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>>;
+
+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;
+}
+declare function WalletProvider({ children, config }: WalletProviderProps): react__default.JSX.Element;
+declare function useWallet(): WalletContextValue;
+
+declare function useConnect(): {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    isConnecting: boolean;
+};
+declare function useWalletStatus(): {
+    isAuthenticated: boolean;
+    authenticated: boolean;
+    error: string | null;
+    session: UserSession | null;
+    isInitialized: boolean;
+    ready: boolean;
+};
+declare function useActiveWallet(): {
+    wallet: WalletClient | null;
+};
+declare function useLoginModal({ client, isOpen, onClose, onLogin, isLoading, }: LoginModalProps): {
+    email: string;
+    setEmail: react.Dispatch<react.SetStateAction<string>>;
+    emailSent: boolean;
+    setEmailSent: react.Dispatch<react.SetStateAction<boolean>>;
+    sendingCode: boolean;
+    setVerificationCode: react.Dispatch<react.SetStateAction<string[]>>;
+    verificationCode: string[];
+    verifyingCode: boolean;
+    connectingPhantom: boolean;
+    inputRefs: 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: react.Dispatch<react.SetStateAction<string>>;
+    phoneSent: boolean;
+    setPhoneSent: react.Dispatch<react.SetStateAction<boolean>>;
+    onOauthLogin: (type: "google" | "twitter") => Promise<void>;
+    handlePhantomLogin: () => Promise<void>;
+    isOpen: boolean;
+    onClose: () => void;
+    onLogin: ((walletInfo: WalletInfo) => void) | undefined;
+    isLoading: boolean;
+};
+
+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;
+}
+
+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;
+    };
+};
+
+declare const injectStyles: () => void;
+
+declare function useCoinbaseOnramp(): {
+    getCoinbaseOnrampUrl: (amount: number, blockchain?: "solana" | "ethereum", redirectUrl?: string) => Promise<string>;
+};
+
+export { Network, SocialType, Storage, WalletClient, WalletProvider, WalletType, injectStyles, isVersionedTransaction, theme, useActiveWallet, useCoinbaseOnramp, useConnect, useLoginModal, useWallet, useWalletStatus };
+export type { AccountInfo, ApiResponse, CoinbaseOnrampRequest, IModalManager, LoginModalProps, LoginType, MiddleAccount, MiddleAccountRequest, OrderState, SignMessageResponse, SignRequestV1, SignRequestV2, SignTransactionResponse, SignTransactionReturnType, Social, SocialInfo, SupportedTransactionVersions, TransactionOrVersionedTransaction, UnsignedTx, UserSession, Wallet, WalletInfo, WalletProviderConfig };

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "superstack-wallet-sdk",
+  "version": "0.4.2",
+  "description": "A wallet SDK for superstack",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/esm/src/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:types": "tsc --emitDeclarationOnly --outDir dist/types",
+    "build:js": "rollup -c rollup.config.mjs",
+    "build": "rimraf dist && npm run build:types && npm run build:js",
+    "dev": "rollup -c rollup.config.mjs -w",
+    "dev:fast": "rollup -c rollup.config.mjs -w --no-treeshake",
+    "dev:example": "sh ./dev.sh",
+    "lint": "eslint . --ext .ts,.tsx",
+    "test": "jest",
+    "publish:patch": "npm version patch && npm run build && npm publish",
+    "publish:minor": "npm version minor && npm run build && npm publish",
+    "publish:major": "npm version major && npm run build && npm publish"
+  },
+  "keywords": [
+    "solana",
+    "wallet",
+    "blockchain",
+    "web3",
+    "sdk"
+  ],
+  "author": "MickWang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/superstackOfficial/superstack-wallet-sdk"
+  },
+  "peerDependencies": {
+    "@solana/web3.js": "^1.73.0",
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "dependencies": {
+    "@solana/wallet-adapter-base": "^0.9.23",
+    "@solana/web3.js": "^1.98.0",
+    "axios": "^1.8.1",
+    "bs58": "^6.0.0",
+    "buffer": "^6.0.3",
+    "ethers": "^6.13.5",
+    "lucide-react": "^0.477.0",
+    "qs": "^6.14.0",
+    "styled-components": "^6.0.0",
+    "uuid": "^11.1.0",
+    "viem": "^2.26.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "@types/qs": "^6.9.18",
+    "@types/react": "^18.2.61",
+    "@types/react-dom": "^18.2.19",
+    "@types/styled-components": "^5.1.34",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-react": "^7.33.2",
+    "jest": "^29.7.0",
+    "postcss": "^8.4.35",
+    "prettier": "^3.2.5",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.42.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-polyfill-node": "^0.13.0",
+    "rollup-plugin-postcss": "^4.0.2",
+    "rollup-plugin-terser": "^7.0.2",
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.6.2",
+    "typescript": "^5.3.3"
+  }
+}