@ab-org/sdk-core 0.0.1 → 0.1.1

package/dist/core/walletConnector.js

@@ -1,153 +0,0 @@
-import { sessionStore } from "./sessionStore.js";
-import { createWalletExecutionClient } from "./walletExecution.js";
-const ADAPTER_STORAGE_KEY = "ab:wallet:adapterId";
-function getStorage() {
-    try {
-        return typeof localStorage !== "undefined" ? localStorage : null;
-    }
-    catch {
-        return null;
-    }
-}
-function persistAdapterId(adapterId) {
-    const storage = getStorage();
-    if (!storage)
-        return;
-    if (!adapterId) {
-        storage.removeItem(ADAPTER_STORAGE_KEY);
-    }
-    else {
-        storage.setItem(ADAPTER_STORAGE_KEY, adapterId);
-    }
-}
-function readPersistedAdapterId() {
-    const storage = getStorage();
-    if (!storage)
-        return null;
-    return storage.getItem(ADAPTER_STORAGE_KEY);
-}
-export class WalletConnector {
-    constructor(adapters) {
-        this.adapters = adapters;
-        this.currentAdapterId = null;
-        this.currentAdapterId = readPersistedAdapterId();
-    }
-    getAdapterById(adapterId) {
-        const adapter = this.adapters.find((item) => item.id === adapterId);
-        if (!adapter)
-            throw new Error(`Wallet adapter ${adapterId} not registered`);
-        return adapter;
-    }
-    getCurrentAdapter(session = sessionStore.getState().session) {
-        return ((this.currentAdapterId
-            ? this.adapters.find((item) => item.id === this.currentAdapterId)
-            : undefined) ??
-            this.adapters.find((item) => item.getProvider() === session?.provider));
-    }
-    clearActiveSession() {
-        this.currentAdapterId = null;
-        persistAdapterId(null);
-        sessionStore.clearSession();
-    }
-    requireActiveSession() {
-        const session = sessionStore.getState().session;
-        if (!session) {
-            throw new Error("Wallet session missing");
-        }
-        return session;
-    }
-    async connect(adapterId, args) {
-        const adapter = this.getAdapterById(adapterId);
-        const currentAdapter = this.getCurrentAdapter();
-        if (currentAdapter && currentAdapter.id !== adapter.id) {
-            await currentAdapter.disconnect();
-            this.clearActiveSession();
-        }
-        sessionStore.setConnecting(true);
-        try {
-            const session = await adapter.connect(args);
-            this.currentAdapterId = adapter.id;
-            persistAdapterId(adapter.id);
-            sessionStore.setSession(session);
-            sessionStore.setBalance(null);
-            return session;
-        }
-        finally {
-            sessionStore.setConnecting(false);
-        }
-    }
-    async disconnect() {
-        const adapter = this.getCurrentAdapter();
-        if (!adapter)
-            return;
-        await adapter?.disconnect();
-        this.clearActiveSession();
-    }
-    rehydrateSession(adapterId, session) {
-        this.currentAdapterId = adapterId;
-        persistAdapterId(adapterId);
-        sessionStore.rehydrateSession(session);
-        sessionStore.setBalance(null);
-        return session;
-    }
-    /**
-     * Attempt to silently reconnect a wallet whose session was rehydrated
-     * from localStorage. Uses the adapter's `reconnect()` if available,
-     * falling back to `connect()` for backward compatibility.
-     *
-     * Returns the restored session on success, or `null` if reconnection
-     * is not possible (e.g. wallet extension removed, social session expired).
-     */
-    async tryAutoReconnect() {
-        const state = sessionStore.getState();
-        if (!state.session)
-            return null;
-        const adapterId = this.currentAdapterId ?? readPersistedAdapterId();
-        if (!adapterId)
-            return null;
-        const adapter = this.adapters.find((a) => a.id === adapterId);
-        if (!adapter)
-            return null;
-        sessionStore.setConnecting(true);
-        try {
-            const session = adapter.reconnect
-                ? await adapter.reconnect(state.session)
-                : null;
-            if (!session)
-                return null;
-            this.currentAdapterId = adapterId;
-            persistAdapterId(adapterId);
-            sessionStore.rehydrateSession(session);
-            return session;
-        }
-        catch {
-            return null;
-        }
-        finally {
-            sessionStore.setConnecting(false);
-        }
-    }
-    supportsCapability(capability) {
-        const session = this.requireActiveSession();
-        return createWalletExecutionClient(session).supports(capability);
-    }
-    async requestCurrentProvider(payload) {
-        return this.requireActiveSession().provider.request(payload);
-    }
-    async sendEvmTransaction(transaction) {
-        const session = this.requireActiveSession();
-        return createWalletExecutionClient(session).sendTransaction(transaction);
-    }
-    async signEvmTransaction(transaction) {
-        const session = this.requireActiveSession();
-        return createWalletExecutionClient(session).signTransaction(transaction);
-    }
-    async signMessage(message) {
-        const session = this.requireActiveSession();
-        return createWalletExecutionClient(session).signMessage(message);
-    }
-    async signTypedData(typedData) {
-        const session = this.requireActiveSession();
-        return createWalletExecutionClient(session).signTypedData(typedData);
-    }
-}

package/dist/core/walletExecution.d.ts

@@ -1,22 +0,0 @@
-import { type SessionCapabilityCheck, type WalletCapability } from "./capabilities.js";
-import type { EvmTransactionRequest, WalletSession } from "./types.js";
-export interface WalletExecutionClient {
-    readonly session: WalletSession;
-    readonly capabilities: WalletCapability[];
-    supports(capability: WalletCapability): boolean;
-    sendTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signMessage(message: string, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signTypedData(typedData: Record<string, unknown>, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-}
-export declare const getWalletExecutionCapabilities: (session?: WalletSession | null) => WalletCapability[];
-export declare const createWalletExecutionClient: (session?: WalletSession | null) => WalletExecutionClient;
-export declare const createWalletExecutionController: () => {
-    readonly session: WalletSession | null;
-    readonly capabilities: string[];
-    supports(capability: WalletCapability): boolean;
-    sendTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signTransaction(transaction: EvmTransactionRequest, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signMessage(message: string, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-    signTypedData(typedData: Record<string, unknown>, check?: Omit<SessionCapabilityCheck, "capability">): Promise<string>;
-};

package/dist/core/walletExecution.js

@@ -1,89 +0,0 @@
-import { assertSessionCapability, } from "./capabilities.js";
-import { sessionStore } from "./sessionStore.js";
-const requireSession = (session) => {
-    const resolvedSession = session ?? sessionStore.getState().session;
-    if (!resolvedSession) {
-        throw new Error("Wallet session missing");
-    }
-    return resolvedSession;
-};
-const performCapabilityCheck = (session, capability, check) => {
-    assertSessionCapability(session, {
-        capability,
-        chain: check?.chain ?? session.chainContext?.walletChain ?? session.chain,
-        token: check?.token,
-        amount: check?.amount,
-        appId: check?.appId,
-        origin: check?.origin,
-        now: check?.now,
-    });
-};
-export const getWalletExecutionCapabilities = (session) => requireSession(session).capabilities ?? [];
-export const createWalletExecutionClient = (session) => {
-    const resolvedSession = requireSession(session);
-    return {
-        session: resolvedSession,
-        capabilities: resolvedSession.capabilities ?? [],
-        supports(capability) {
-            return this.capabilities.length === 0 || this.capabilities.includes(capability);
-        },
-        async sendTransaction(transaction, check) {
-            performCapabilityCheck(resolvedSession, "eth_sendTransaction", {
-                ...check,
-                amount: check?.amount ?? transaction.value,
-            });
-            return resolvedSession.provider.request({
-                method: "eth_sendTransaction",
-                params: [{ ...transaction, from: transaction.from ?? resolvedSession.address }],
-            });
-        },
-        async signTransaction(transaction, check) {
-            performCapabilityCheck(resolvedSession, "eth_signTransaction", {
-                ...check,
-                amount: check?.amount ?? transaction.value,
-            });
-            return resolvedSession.provider.request({
-                method: "eth_signTransaction",
-                params: [{ ...transaction, from: transaction.from ?? resolvedSession.address }],
-            });
-        },
-        async signMessage(message, check) {
-            performCapabilityCheck(resolvedSession, "personal_sign", check);
-            return resolvedSession.provider.request({
-                method: "personal_sign",
-                params: [message, resolvedSession.address],
-            });
-        },
-        async signTypedData(typedData, check) {
-            performCapabilityCheck(resolvedSession, "eth_signTypedData_v4", check);
-            return resolvedSession.provider.request({
-                method: "eth_signTypedData_v4",
-                params: [resolvedSession.address, JSON.stringify(typedData)],
-            });
-        },
-    };
-};
-export const createWalletExecutionController = () => ({
-    get session() {
-        return sessionStore.getState().session;
-    },
-    get capabilities() {
-        return sessionStore.getState().session?.capabilities ?? [];
-    },
-    supports(capability) {
-        const session = requireSession();
-        return createWalletExecutionClient(session).supports(capability);
-    },
-    sendTransaction(transaction, check) {
-        return createWalletExecutionClient().sendTransaction(transaction, check);
-    },
-    signTransaction(transaction, check) {
-        return createWalletExecutionClient().signTransaction(transaction, check);
-    },
-    signMessage(message, check) {
-        return createWalletExecutionClient().signMessage(message, check);
-    },
-    signTypedData(typedData, check) {
-        return createWalletExecutionClient().signTypedData(typedData, check);
-    },
-});

package/dist/hooks/useAccount.d.ts

@@ -1,11 +0,0 @@
-export declare const createAccountController: () => {
-    readonly session: import("../index.js").WalletSession | null;
-    readonly address: string | null;
-    readonly chain: import("../index.js").SupportedChain | null;
-    readonly balance: import("../index.js").BalanceInfo | null;
-    readonly isConnected: boolean;
-    readonly currentProvider: import("../index.js").WalletProvider | null;
-    readonly chainContext: import("../index.js").ChainContext | null;
-    readonly capabilities: string[];
-    readonly capabilityPolicy: import("../index.js").SessionCapabilityPolicy | null;
-};

package/dist/hooks/useAccount.js

@@ -1,32 +0,0 @@
-import { sessionStore } from "../core/sessionStore.js";
-export const createAccountController = () => {
-    return {
-        get session() {
-            return sessionStore.getState().session;
-        },
-        get address() {
-            return sessionStore.getState().session?.address ?? null;
-        },
-        get chain() {
-            return sessionStore.getState().session?.chain ?? null;
-        },
-        get balance() {
-            return sessionStore.getState().balance;
-        },
-        get isConnected() {
-            return Boolean(sessionStore.getState().session);
-        },
-        get currentProvider() {
-            return sessionStore.getState().session?.provider ?? null;
-        },
-        get chainContext() {
-            return sessionStore.getState().session?.chainContext ?? null;
-        },
-        get capabilities() {
-            return sessionStore.getState().session?.capabilities ?? [];
-        },
-        get capabilityPolicy() {
-            return sessionStore.getState().session?.capabilityPolicy ?? null;
-        },
-    };
-};

package/dist/hooks/useWalletConnect.d.ts

@@ -1,16 +0,0 @@
-import { WalletConnector } from "../core/walletConnector.js";
-import type { WalletCapability } from "../core/capabilities.js";
-import type { WalletConnectArgs, WalletSession } from "../core/types.js";
-export interface WalletConnectControllerOptions {
-    connector: WalletConnector;
-    defaultAdapterId?: string;
-}
-export declare const createWalletConnectController: ({ connector, defaultAdapterId, }: WalletConnectControllerOptions) => {
-    readonly openModal: (adapterId?: string | undefined, args?: WalletConnectArgs) => Promise<void>;
-    readonly disconnect: () => Promise<void>;
-    readonly rehydrate: (adapterId: string, session: WalletSession) => WalletSession;
-    readonly tryAutoReconnect: () => Promise<WalletSession | null>;
-    readonly supports: (capability: WalletCapability) => boolean;
-    readonly isConnected: boolean;
-    readonly isConnecting: boolean;
-};

package/dist/hooks/useWalletConnect.js

@@ -1,24 +0,0 @@
-import { sessionStore } from "../core/sessionStore.js";
-export const createWalletConnectController = ({ connector, defaultAdapterId, }) => {
-    return {
-        openModal: async (adapterId = defaultAdapterId, args) => {
-            if (!adapterId)
-                throw new Error("No adapter id provided");
-            await connector.connect(adapterId, args);
-        },
-        disconnect: () => connector.disconnect(),
-        rehydrate: (adapterId, session) => connector.rehydrateSession(adapterId, session),
-        tryAutoReconnect: () => connector.tryAutoReconnect(),
-        supports(capability) {
-            if (!sessionStore.getState().session)
-                return false;
-            return connector.supportsCapability(capability);
-        },
-        get isConnected() {
-            return Boolean(sessionStore.getState().session);
-        },
-        get isConnecting() {
-            return sessionStore.getState().isConnecting;
-        },
-    };
-};

package/dist/providers/base.d.ts

@@ -1,15 +0,0 @@
-import type { ProviderCategory, WalletAdapter, WalletConnectArgs, WalletProvider, WalletSession } from "../core/types.js";
-export declare abstract class AbstractProvider implements WalletAdapter {
-    abstract readonly id: string;
-    abstract readonly title: string;
-    abstract readonly category: ProviderCategory;
-    protected currentSession: WalletSession | null;
-    abstract connect(args?: WalletConnectArgs): Promise<WalletSession>;
-    disconnect(): Promise<void>;
-    protected setSession(session: WalletSession): WalletSession;
-    protected clearSession(): void;
-    protected get session(): WalletSession | null;
-    protected requireSession(message?: string): WalletSession;
-    getProvider(): WalletProvider | null;
-    reconnect(_persistedSession: WalletSession): Promise<WalletSession | null>;
-}

package/dist/providers/base.js

@@ -1,30 +0,0 @@
-export class AbstractProvider {
-    constructor() {
-        this.currentSession = null;
-    }
-    async disconnect() {
-        this.clearSession();
-    }
-    setSession(session) {
-        this.currentSession = session;
-        return session;
-    }
-    clearSession() {
-        this.currentSession = null;
-    }
-    get session() {
-        return this.currentSession;
-    }
-    requireSession(message = `${this.title} session missing`) {
-        if (!this.currentSession) {
-            throw new Error(message);
-        }
-        return this.currentSession;
-    }
-    getProvider() {
-        return this.currentSession?.provider ?? null;
-    }
-    async reconnect(_persistedSession) {
-        return null;
-    }
-}

package/dist/providers/plugin/injectedEvmProvider.d.ts

@@ -1,112 +0,0 @@
-import { AbstractProvider } from "../base.js";
-import type { WalletConnectArgs, WalletProvider, WalletSession } from "../../core/types.js";
-export interface InjectedEthereumProvider extends WalletProvider {
-    request<T = unknown>(args: {
-        method: string;
-        params?: unknown[];
-    }): Promise<T>;
-    providers?: InjectedEthereumProvider[];
-    isMetaMask?: boolean;
-    isCoinbaseWallet?: boolean;
-    isTrust?: boolean;
-    isTrustWallet?: boolean;
-    isPhantom?: boolean;
-    isRabby?: boolean;
-    isOkxWallet?: boolean;
-    isBitKeep?: boolean;
-    isRainbow?: boolean;
-    isZerion?: boolean;
-    isBraveWallet?: boolean;
-    isBitget?: boolean;
-}
-export interface EIP6963ProviderInfo {
-    uuid: string;
-    name: string;
-    icon: string;
-    rdns: string;
-}
-export interface EIP6963ProviderDetail {
-    info: EIP6963ProviderInfo;
-    provider: InjectedEthereumProvider;
-}
-declare global {
-    interface Window {
-        ethereum?: InjectedEthereumProvider;
-        okxwallet?: InjectedEthereumProvider | {
-            ethereum?: InjectedEthereumProvider;
-        };
-        coinbaseWalletExtension?: InjectedEthereumProvider;
-        trustwallet?: InjectedEthereumProvider | {
-            ethereum?: InjectedEthereumProvider;
-        };
-        phantom?: {
-            ethereum?: InjectedEthereumProvider;
-        };
-        rabby?: InjectedEthereumProvider;
-        bitkeep?: InjectedEthereumProvider | {
-            ethereum?: InjectedEthereumProvider;
-        };
-        rainbow?: {
-            ethereum?: InjectedEthereumProvider;
-        };
-        zerionWallet?: InjectedEthereumProvider;
-        bitget?: InjectedEthereumProvider | {
-            ethereum?: InjectedEthereumProvider;
-        };
-    }
-}
-export declare function discoverEIP6963Providers(): EIP6963ProviderDetail[];
-export declare function findInjectedProvider(predicate: (provider: InjectedEthereumProvider) => boolean): InjectedEthereumProvider | undefined;
-export declare function findEIP6963Provider(predicate: (detail: EIP6963ProviderDetail) => boolean): InjectedEthereumProvider | undefined;
-export interface InjectedWalletConfig {
-    id: string;
-    title: string;
-    resolveProvider: () => InjectedEthereumProvider | undefined;
-}
-/**
- * Force wallet to BSC_TENDERLY (chainId 3131). If the chain is missing (4902), add it then switch.
- * Call after external wallet connect so subsequent business runs on Tenderly BSC.
- */
-export declare function switchToFallbackBscTestnet(provider: InjectedEthereumProvider): Promise<void>;
-export declare class InjectedEvmProvider extends AbstractProvider {
-    private config;
-    private injected?;
-    readonly id: string;
-    readonly title: string;
-    readonly category: "plugin";
-    constructor(config: InjectedWalletConfig, injected?: InjectedEthereumProvider | undefined);
-    isAvailable(): boolean;
-    protected get client(): InjectedEthereumProvider;
-    connect(_args?: WalletConnectArgs): Promise<WalletSession>;
-    reconnect(_persistedSession: WalletSession): Promise<WalletSession | null>;
-}
-export declare class MetaMaskProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class OKXProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class CoinbaseWalletProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class TrustWalletProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class PhantomProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class RabbyProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class RainbowProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class ZerionProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class BraveWalletProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}
-export declare class BitgetProvider extends InjectedEvmProvider {
-    constructor(injected?: InjectedEthereumProvider);
-}