@ab-org/sdk-core 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ab-org/sdk-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "files": [
     "dist/**/*",
@@ -14,14 +14,15 @@
   },
   "dependencies": {
     "@cubist-labs/cubesigner-sdk": "^0.4.219",
-    "eventemitter3": "^5.0.1",
-    "@ab-org/wallet-utils": "0.0.7"
+    "eventemitter3": "^5.0.1"
   },
   "devDependencies": {
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "tsup": "^8.5.1",
+    "@ab-org/wallet-utils": "0.0.7"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsup",
     "lint": "eslint 'src/**/*.{ts,tsx}'",
     "test": "vitest run --passWithNoTests"
   }

package/dist/core/capabilities.d.ts

@@ -1,32 +0,0 @@
-import type { SupportedChain, SupportedToken, WalletSession } from "./types.js";
-export type WalletCapability = "eth_accounts" | "eth_requestAccounts" | "eth_chainId" | "eth_signTransaction" | "eth_sendTransaction" | "personal_sign" | "eth_signTypedData_v4" | "wallet_disconnect" | "wallet_rehydrate" | string;
-export interface SessionCapabilityPolicy {
-    id: string;
-    appId?: string;
-    origin?: string;
-    expiresAt?: number;
-    methods?: WalletCapability[];
-    chains?: SupportedChain[];
-    tokens?: SupportedToken[];
-    maxAmount?: string;
-    revocable?: boolean;
-    metadata?: Record<string, unknown>;
-}
-export interface SessionCapabilityCheck {
-    capability: WalletCapability;
-    chain?: SupportedChain;
-    token?: SupportedToken;
-    amount?: string | number | bigint;
-    appId?: string;
-    origin?: string;
-    now?: number;
-}
-export declare class SessionCapabilityError extends Error {
-    constructor(message: string);
-}
-export declare const createSessionCapabilityPolicy: (input?: Partial<SessionCapabilityPolicy>) => SessionCapabilityPolicy;
-export declare const isSessionExpired: (session: Pick<WalletSession, "expiresAt"> | null | undefined, now?: number) => boolean;
-export declare const isCapabilityPolicyExpired: (policy: SessionCapabilityPolicy | null | undefined, now?: number) => boolean;
-export declare const sessionSupportsCapability: (session: Pick<WalletSession, "capabilities"> | null | undefined, capability: WalletCapability) => boolean;
-export declare const describeSessionCapabilityPolicy: (policy: SessionCapabilityPolicy | null | undefined) => string[];
-export declare const assertSessionCapability: (session: WalletSession, check: SessionCapabilityCheck) => void;

package/dist/core/capabilities.js

@@ -1,88 +0,0 @@
-export class SessionCapabilityError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "SessionCapabilityError";
-    }
-}
-const toBigIntAmount = (value) => {
-    if (typeof value === "bigint")
-        return value;
-    if (typeof value === "number")
-        return BigInt(value);
-    return BigInt(value);
-};
-export const createSessionCapabilityPolicy = (input = {}) => ({
-    id: input.id ?? `cap:${Date.now()}`,
-    appId: input.appId,
-    origin: input.origin,
-    expiresAt: input.expiresAt,
-    methods: input.methods,
-    chains: input.chains,
-    tokens: input.tokens,
-    maxAmount: input.maxAmount,
-    revocable: input.revocable ?? true,
-    metadata: input.metadata,
-});
-export const isSessionExpired = (session, now = Date.now()) => Boolean(session?.expiresAt && session.expiresAt <= now);
-export const isCapabilityPolicyExpired = (policy, now = Date.now()) => Boolean(policy?.expiresAt && policy.expiresAt <= now);
-export const sessionSupportsCapability = (session, capability) => {
-    const capabilities = session?.capabilities;
-    if (!capabilities || capabilities.length === 0)
-        return true;
-    return capabilities.includes(capability);
-};
-export const describeSessionCapabilityPolicy = (policy) => {
-    if (!policy)
-        return [];
-    const lines = [];
-    if (policy.origin)
-        lines.push(`Origin: ${policy.origin}`);
-    if (policy.appId)
-        lines.push(`App: ${policy.appId}`);
-    if (policy.methods?.length)
-        lines.push(`Methods: ${policy.methods.join(", ")}`);
-    if (policy.chains?.length)
-        lines.push(`Chains: ${policy.chains.join(", ")}`);
-    if (policy.tokens?.length)
-        lines.push(`Tokens: ${policy.tokens.join(", ")}`);
-    if (policy.maxAmount)
-        lines.push(`Max amount: ${policy.maxAmount}`);
-    if (policy.expiresAt)
-        lines.push(`Expires at: ${new Date(policy.expiresAt).toISOString()}`);
-    return lines;
-};
-export const assertSessionCapability = (session, check) => {
-    const now = check.now ?? Date.now();
-    if (isSessionExpired(session, now)) {
-        throw new SessionCapabilityError("Wallet session has expired");
-    }
-    const policy = session.capabilityPolicy;
-    if (isCapabilityPolicyExpired(policy, now)) {
-        throw new SessionCapabilityError("Capability session has expired");
-    }
-    if (!sessionSupportsCapability(session, check.capability)) {
-        throw new SessionCapabilityError(`Wallet session does not support capability "${check.capability}"`);
-    }
-    if (!policy)
-        return;
-    if (policy.appId && check.appId && policy.appId !== check.appId) {
-        throw new SessionCapabilityError("Capability session is scoped to a different app");
-    }
-    if (policy.origin && check.origin && policy.origin !== check.origin) {
-        throw new SessionCapabilityError("Capability session is scoped to a different origin");
-    }
-    if (policy.methods?.length && !policy.methods.includes(check.capability)) {
-        throw new SessionCapabilityError(`Capability "${check.capability}" is not allowed for this session`);
-    }
-    if (check.chain && policy.chains?.length && !policy.chains.includes(check.chain)) {
-        throw new SessionCapabilityError(`Chain "${check.chain}" is not allowed for this session`);
-    }
-    if (check.token && policy.tokens?.length && !policy.tokens.includes(check.token)) {
-        throw new SessionCapabilityError(`Token "${check.token}" is not allowed for this session`);
-    }
-    if (policy.maxAmount && check.amount !== undefined) {
-        if (toBigIntAmount(check.amount) > toBigIntAmount(policy.maxAmount)) {
-            throw new SessionCapabilityError("Requested amount exceeds the capability session limit");
-        }
-    }
-};

package/dist/core/chains.d.ts

@@ -1,23 +0,0 @@
-import type { SupportedChain } from "./types.js";
-export type ChainNamespace = "evm" | "solana" | "ab-core";
-export type ChainRpcFamily = "evm" | "solana" | "custom";
-export interface ChainDescriptor {
-    chain: SupportedChain;
-    namespace: ChainNamespace;
-    reference: string;
-    label: string;
-    rpcFamily: ChainRpcFamily;
-    evmChainId?: number;
-    supportsSmartSessions: boolean;
-    supportsAccountAbstraction: boolean;
-}
-export interface ChainContext {
-    walletChain: SupportedChain;
-    walletChainDescriptor: ChainDescriptor;
-    settlementChain: SupportedChain;
-    settlementChainDescriptor: ChainDescriptor;
-}
-export declare const getChainDescriptor: (chain: SupportedChain) => ChainDescriptor;
-export declare const getAllChainDescriptors: () => ChainDescriptor[];
-export declare const getSupportedChainFromEvmChainId: (value: string | number | bigint) => SupportedChain;
-export declare const createChainContext: (walletChain: SupportedChain, settlementChain?: SupportedChain) => ChainContext;

package/dist/core/chains.js

@@ -1,83 +0,0 @@
-const chainDescriptors = {
-    AB_CORE: {
-        chain: "AB_CORE",
-        namespace: "ab-core",
-        reference: "ab:core",
-        label: "AB Core",
-        rpcFamily: "custom",
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: true,
-    },
-    ETH: {
-        chain: "ETH",
-        namespace: "evm",
-        reference: "eip155:1",
-        label: "Ethereum",
-        rpcFamily: "evm",
-        evmChainId: 1,
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: true,
-    },
-    BSC: {
-        chain: "BSC",
-        namespace: "evm",
-        reference: "eip155:56",
-        label: "BNB Smart Chain",
-        rpcFamily: "evm",
-        evmChainId: 56,
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: false,
-    },
-    ETH_TENDERLY: {
-        chain: "ETH_TENDERLY",
-        namespace: "evm",
-        reference: "eip155:3030",
-        label: "Ethereum Tenderly",
-        rpcFamily: "evm",
-        evmChainId: 3030,
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: true,
-    },
-    BSC_TENDERLY: {
-        chain: "BSC_TENDERLY",
-        namespace: "evm",
-        reference: "eip155:3131",
-        label: "BNB Smart Chain Tenderly",
-        rpcFamily: "evm",
-        evmChainId: 3131,
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: false,
-    },
-    SOL: {
-        chain: "SOL",
-        namespace: "solana",
-        reference: "solana:mainnet-beta",
-        label: "Solana",
-        rpcFamily: "solana",
-        supportsSmartSessions: true,
-        supportsAccountAbstraction: false,
-    },
-};
-export const getChainDescriptor = (chain) => chainDescriptors[chain];
-export const getAllChainDescriptors = () => Object.values(chainDescriptors);
-const normalizeEvmChainId = (value) => {
-    if (typeof value === "number")
-        return value;
-    if (typeof value === "bigint")
-        return Number(value);
-    return Number(BigInt(value));
-};
-export const getSupportedChainFromEvmChainId = (value) => {
-    const chainId = normalizeEvmChainId(value);
-    const descriptor = getAllChainDescriptors().find((item) => item.namespace === "evm" && item.evmChainId === chainId);
-    if (!descriptor) {
-        throw new Error(`Unsupported EVM chainId: ${chainId}`);
-    }
-    return descriptor.chain;
-};
-export const createChainContext = (walletChain, settlementChain = walletChain) => ({
-    walletChain,
-    walletChainDescriptor: getChainDescriptor(walletChain),
-    settlementChain,
-    settlementChainDescriptor: getChainDescriptor(settlementChain),
-});

package/dist/core/errors.d.ts

@@ -1,9 +0,0 @@
-export declare const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-export declare class EvmTransactionSigningUnsupportedError extends Error {
-    readonly providerName: string;
-    readonly cause?: unknown | undefined;
-    readonly code = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-    constructor(providerName: string, cause?: unknown | undefined);
-}
-export declare const isUnsupportedEvmTransactionSigningError: (error: unknown) => boolean;
-export declare const normalizeEvmTransactionSigningError: (providerName: string, error: unknown) => Error;

package/dist/core/errors.js

@@ -1,51 +0,0 @@
-export const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-export class EvmTransactionSigningUnsupportedError extends Error {
-    constructor(providerName, cause) {
-        super(`${providerName} does not support EVM transaction signing`);
-        this.providerName = providerName;
-        this.cause = cause;
-        this.code = EVM_TRANSACTION_SIGNING_UNSUPPORTED;
-        this.name = "EvmTransactionSigningUnsupportedError";
-    }
-}
-const getErrorCode = (error) => {
-    if (typeof error !== "object" || error === null || !("code" in error))
-        return undefined;
-    const { code } = error;
-    return typeof code === "number" || typeof code === "string" ? code : undefined;
-};
-const getErrorMessage = (error) => {
-    if (error instanceof Error)
-        return error.message;
-    if (typeof error === "object" && error !== null && "message" in error) {
-        const { message } = error;
-        if (typeof message === "string")
-            return message;
-    }
-    return String(error);
-};
-export const isUnsupportedEvmTransactionSigningError = (error) => {
-    if (error instanceof EvmTransactionSigningUnsupportedError) {
-        return true;
-    }
-    const code = getErrorCode(error);
-    if (code === 4200 || code === -32601) {
-        return true;
-    }
-    const message = getErrorMessage(error).toLowerCase();
-    return (message.includes("eth_signtransaction") &&
-        (message.includes("unsupported") ||
-            message.includes("not support") ||
-            message.includes("not found") ||
-            message.includes("does not exist") ||
-            message.includes("unrecognized")));
-};
-export const normalizeEvmTransactionSigningError = (providerName, error) => {
-    if (error instanceof Error && !isUnsupportedEvmTransactionSigningError(error)) {
-        return error;
-    }
-    if (isUnsupportedEvmTransactionSigningError(error)) {
-        return new EvmTransactionSigningUnsupportedError(providerName, error);
-    }
-    return error instanceof Error ? error : new Error(String(error));
-};

package/dist/core/sessionStore.d.ts

@@ -1,26 +0,0 @@
-import EventEmitter from "eventemitter3";
-import type { BalanceInfo, WalletSession, WalletState } from "./types.js";
-export type WalletEvents = {
-    "session:changed": [WalletSession | null];
-    "session:rehydrated": [WalletSession];
-    "session:expired": [WalletSession];
-    "session:revoked": [WalletSession];
-    "balance:changed": [BalanceInfo | null];
-    "connecting:changed": [boolean];
-};
-export declare class SessionStore {
-    private state;
-    private emitter;
-    constructor();
-    getState(): WalletState;
-    setConnecting(flag: boolean): void;
-    setSession(session: WalletSession | null): void;
-    rehydrateSession(session: WalletSession): void;
-    clearSession(): void;
-    expireSession(): void;
-    revokeSession(): void;
-    setBalance(balance: BalanceInfo | null): void;
-    on<T extends keyof WalletEvents>(event: T, listener: (...args: WalletEvents[T]) => void): () => EventEmitter<WalletEvents, any>;
-    private tryRehydrate;
-}
-export declare const sessionStore: SessionStore;

package/dist/core/sessionStore.js

@@ -1,129 +0,0 @@
-import EventEmitter from "eventemitter3";
-const STORAGE_KEY = "ab:wallet:session";
-function getStorage() {
-    try {
-        return typeof localStorage !== "undefined" ? localStorage : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Only persist known JSON-serializable fields; session may contain DOM/React refs or circular refs. */
-function persistSession(session) {
-    const storage = getStorage();
-    if (!storage)
-        return;
-    if (!session) {
-        storage.removeItem(STORAGE_KEY);
-        return;
-    }
-    const serializable = {
-        address: session.address,
-        chain: session.chain,
-        walletType: session.walletType,
-        authSource: session.authSource,
-        sessionId: session.sessionId,
-        expiresAt: session.expiresAt,
-    };
-    if (session.capabilities?.length) {
-        serializable.capabilities = session.capabilities;
-    }
-    try {
-        storage.setItem(STORAGE_KEY, JSON.stringify(serializable));
-    }
-    catch {
-        storage.removeItem(STORAGE_KEY);
-    }
-}
-function readPersistedSession() {
-    const storage = getStorage();
-    if (!storage)
-        return null;
-    const raw = storage.getItem(STORAGE_KEY);
-    if (!raw)
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        storage.removeItem(STORAGE_KEY);
-        return null;
-    }
-}
-const staleProvider = {
-    request() {
-        return Promise.reject(new Error("Session restored from cache. Reconnect your wallet for transactions."));
-    },
-    disconnect() {
-        return Promise.resolve();
-    },
-};
-export class SessionStore {
-    constructor() {
-        this.state = {
-            session: null,
-            balance: null,
-            isConnecting: false,
-        };
-        this.emitter = new EventEmitter();
-        this.tryRehydrate();
-    }
-    getState() {
-        return { ...this.state };
-    }
-    setConnecting(flag) {
-        this.state.isConnecting = flag;
-        this.emitter.emit("connecting:changed", flag);
-    }
-    setSession(session) {
-        this.state.session = session;
-        persistSession(session);
-        this.emitter.emit("session:changed", session);
-    }
-    rehydrateSession(session) {
-        this.state.session = session;
-        persistSession(session);
-        this.emitter.emit("session:changed", session);
-        this.emitter.emit("session:rehydrated", session);
-    }
-    clearSession() {
-        this.state.session = null;
-        this.state.balance = null;
-        persistSession(null);
-        this.emitter.emit("session:changed", null);
-        this.emitter.emit("balance:changed", null);
-    }
-    expireSession() {
-        const currentSession = this.state.session;
-        if (!currentSession)
-            return;
-        this.clearSession();
-        this.emitter.emit("session:expired", currentSession);
-    }
-    revokeSession() {
-        const currentSession = this.state.session;
-        if (!currentSession)
-            return;
-        this.clearSession();
-        this.emitter.emit("session:revoked", currentSession);
-    }
-    setBalance(balance) {
-        this.state.balance = balance;
-        this.emitter.emit("balance:changed", balance);
-    }
-    on(event, listener) {
-        this.emitter.on(event, listener);
-        return () => this.emitter.off(event, listener);
-    }
-    tryRehydrate() {
-        const persisted = readPersistedSession();
-        if (!persisted)
-            return;
-        if (persisted.expiresAt && persisted.expiresAt <= Date.now()) {
-            persistSession(null);
-            return;
-        }
-        this.state.session = { ...persisted, provider: staleProvider };
-    }
-}
-export const sessionStore = new SessionStore();

package/dist/core/types.d.ts

@@ -1,75 +0,0 @@
-import type { SessionCapabilityPolicy, WalletCapability } from "./capabilities.js";
-import type { ChainContext } from "./chains.js";
-export type SupportedChain = "AB_CORE" | "ETH" | "BSC" | "SOL" | "ETH_TENDERLY" | "BSC_TENDERLY";
-export type SupportedToken = "USD1" | "USDC" | "USDT" | "ETH" | "AB";
-export type ProviderCategory = "plugin" | "social";
-export type WalletType = "injected" | "social" | "smart";
-export type WalletAuthSource = "google" | "twitter" | "wallet" | "session";
-export type EvmQuantity = string | number | bigint;
-export interface EvmAccessListItem {
-    address: string;
-    storageKeys?: string[];
-}
-export interface EvmTransactionRequest {
-    from?: string;
-    to?: string;
-    data?: string;
-    gas?: EvmQuantity;
-    gasPrice?: EvmQuantity;
-    maxFeePerGas?: EvmQuantity;
-    maxPriorityFeePerGas?: EvmQuantity;
-    nonce?: EvmQuantity;
-    value?: EvmQuantity;
-    type?: EvmQuantity;
-    chainId?: EvmQuantity;
-    accessList?: EvmAccessListItem[];
-}
-export interface WalletProviderRequest {
-    method: string;
-    params?: unknown[];
-}
-export interface WalletProvider {
-    request<T = unknown>(payload: WalletProviderRequest): Promise<T>;
-    disconnect(): Promise<void>;
-}
-export interface WalletConnectArgs {
-    options?: unknown;
-    payload?: unknown;
-}
-export interface WalletAdapter {
-    id: string;
-    title: string;
-    icon?: string;
-    category?: ProviderCategory;
-    connect(args?: WalletConnectArgs): Promise<WalletSession>;
-    disconnect(): Promise<void>;
-    getProvider(): WalletProvider | null;
-    /**
-     * Silently restore a wallet session from persisted data without user interaction.
-     * Returns a fresh session if the wallet can be reconnected, or null otherwise.
-     */
-    reconnect?(persistedSession: WalletSession): Promise<WalletSession | null>;
-}
-export interface WalletSession {
-    address: string;
-    chain: SupportedChain;
-    provider: WalletProvider;
-    walletType?: WalletType;
-    authSource?: WalletAuthSource;
-    sessionId?: string;
-    expiresAt?: number;
-    capabilities?: WalletCapability[];
-    sessionData?: unknown;
-    chainContext?: ChainContext;
-    capabilityPolicy?: SessionCapabilityPolicy;
-}
-export interface BalanceInfo {
-    formatted: string;
-    symbol: SupportedToken;
-    wei: bigint;
-}
-export interface WalletState {
-    session: WalletSession | null;
-    balance: BalanceInfo | null;
-    isConnecting: boolean;
-}

package/dist/core/types.js

@@ -1 +0,0 @@
-export {};

package/dist/core/walletConnector.d.ts

@@ -1,29 +0,0 @@
-import { type WalletCapability } from "./capabilities.js";
-import type { EvmTransactionRequest, WalletAdapter, WalletConnectArgs, WalletProviderRequest, WalletSession } from "./types.js";
-export declare class WalletConnector {
-    private adapters;
-    private currentAdapterId;
-    constructor(adapters: WalletAdapter[]);
-    private getAdapterById;
-    private getCurrentAdapter;
-    private clearActiveSession;
-    private requireActiveSession;
-    connect(adapterId: string, args?: WalletConnectArgs): Promise<WalletSession>;
-    disconnect(): Promise<void>;
-    rehydrateSession(adapterId: string, session: WalletSession): WalletSession;
-    /**
-     * 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).
-     */
-    tryAutoReconnect(): Promise<WalletSession | null>;
-    supportsCapability(capability: WalletCapability): boolean;
-    requestCurrentProvider<T = unknown>(payload: WalletProviderRequest): Promise<T>;
-    sendEvmTransaction(transaction: EvmTransactionRequest): Promise<string>;
-    signEvmTransaction(transaction: EvmTransactionRequest): Promise<string>;
-    signMessage(message: string): Promise<string>;
-    signTypedData(typedData: Record<string, unknown>): Promise<string>;
-}