@ab-org/sdk-core 0.1.0 → 0.1.2-beta.0

package/dist/providers/social/cubistEvmWalletProvider.js

@@ -1,175 +0,0 @@
-import { EvmSigner } from "@cubist-labs/cubesigner-sdk";
-const evmChainIdMap = {
-    ETH: 1,
-    BSC: 56,
-};
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const toBigIntQuantity = (value) => {
-    if (typeof value === "bigint")
-        return value;
-    if (typeof value === "number") {
-        if (!Number.isInteger(value) || value < 0) {
-            throw new Error(`Invalid EVM quantity number: ${value}`);
-        }
-        return BigInt(value);
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new Error("EVM quantity cannot be empty");
-    }
-    if (/^0x[0-9a-fA-F]+$/.test(trimmed) || /^\d+$/.test(trimmed)) {
-        return BigInt(trimmed);
-    }
-    throw new Error(`Invalid EVM quantity string: ${value}`);
-};
-const toHexQuantity = (value) => {
-    if (value === undefined)
-        return undefined;
-    return `0x${toBigIntQuantity(value).toString(16)}`;
-};
-const normalizeAccessList = (accessList) => {
-    if (!accessList)
-        return undefined;
-    return accessList.map((item) => ({
-        address: item.address,
-        storageKeys: item.storageKeys,
-    }));
-};
-const textEncoder = new TextEncoder();
-const resolveTransactionType = (transaction) => {
-    if (transaction.type !== undefined) {
-        const normalized = toHexQuantity(transaction.type);
-        if (normalized === "0x0" || normalized === "0x1" || normalized === "0x2") {
-            return normalized;
-        }
-        throw new Error(`Unsupported EVM transaction type for Cubist: ${normalized}`);
-    }
-    if (transaction.maxFeePerGas !== undefined || transaction.maxPriorityFeePerGas !== undefined) {
-        return "0x2";
-    }
-    if (transaction.accessList?.length) {
-        return "0x1";
-    }
-    return "0x0";
-};
-const toCubistSignRequest = (address, chain, transaction) => {
-    const resolvedChainId = (transaction.chainId !== undefined ? Number(toBigIntQuantity(transaction.chainId)) : undefined) ??
-        evmChainIdMap[chain];
-    if (!resolvedChainId) {
-        throw new Error("Cubist signing requires an EVM chainId");
-    }
-    const type = resolveTransactionType(transaction);
-    const commonFields = {
-        from: transaction.from ?? address,
-        to: transaction.to,
-        data: transaction.data,
-        gas: toHexQuantity(transaction.gas),
-        nonce: toHexQuantity(transaction.nonce),
-        value: toHexQuantity(transaction.value),
-    };
-    const accessList = normalizeAccessList(transaction.accessList);
-    const tx = type === "0x2"
-        ? {
-            ...commonFields,
-            type,
-            ...(accessList ? { accessList } : {}),
-            maxFeePerGas: toHexQuantity(transaction.maxFeePerGas),
-            maxPriorityFeePerGas: toHexQuantity(transaction.maxPriorityFeePerGas),
-        }
-        : type === "0x1"
-            ? {
-                ...commonFields,
-                type,
-                ...(accessList ? { accessList } : {}),
-                gasPrice: toHexQuantity(transaction.gasPrice),
-            }
-            : {
-                ...commonFields,
-                type,
-                gasPrice: toHexQuantity(transaction.gasPrice),
-            };
-    return {
-        chain_id: resolvedChainId,
-        tx,
-    };
-};
-const getTransactionParam = (params) => {
-    const candidate = params?.[0];
-    if (!isRecord(candidate)) {
-        throw new Error("eth_signTransaction requires a transaction object");
-    }
-    return candidate;
-};
-const toHexBytes = (value) => {
-    if (/^0x[0-9a-fA-F]*$/.test(value))
-        return value;
-    return `0x${Array.from(textEncoder.encode(value))
-        .map((byte) => byte.toString(16).padStart(2, "0"))
-        .join("")}`;
-};
-const getMessageParam = (address, params) => {
-    const [first, second] = params ?? [];
-    if (typeof second === "string" && second.toLowerCase() === address.toLowerCase()) {
-        return String(first ?? "");
-    }
-    if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
-        return String(second ?? "");
-    }
-    return String(first ?? "");
-};
-const getTypedDataParam = (address, params) => {
-    const [first, second] = params ?? [];
-    if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
-        return typeof second === "string" ? JSON.parse(second) : (second ?? {});
-    }
-    return typeof second === "string" ? JSON.parse(second) : (second ?? first ?? {});
-};
-export const createCubistEvmWalletProvider = ({ session, address, chain, }) => {
-    const signer = new EvmSigner(address, session.client);
-    return {
-        async request(payload) {
-            switch (payload.method) {
-                case "eth_accounts":
-                case "eth_requestAccounts":
-                    return [address];
-                case "eth_chainId": {
-                    const chainId = evmChainIdMap[chain];
-                    if (!chainId) {
-                        throw new Error(`CubistProvider: chain ${chain} does not expose an EVM chainId`);
-                    }
-                    return `0x${chainId.toString(16)}`;
-                }
-                case "eth_signTransaction": {
-                    const transaction = getTransactionParam(payload.params);
-                    const signRequest = toCubistSignRequest(address, chain, transaction);
-                    return (await signer.signTransaction(signRequest));
-                }
-                case "personal_sign": {
-                    const message = getMessageParam(address, payload.params);
-                    return (await signer.signEip191({
-                        data: toHexBytes(message),
-                    }));
-                }
-                case "eth_signTypedData_v4": {
-                    const typedData = getTypedDataParam(address, payload.params);
-                    const domain = typedData.domain;
-                    const chainId = domain?.chainId !== undefined
-                        ? Number(toBigIntQuantity(domain.chainId))
-                        : evmChainIdMap[chain];
-                    if (!chainId) {
-                        throw new Error("CubistProvider: typed data signing requires an EVM chainId");
-                    }
-                    return (await signer.signEip712({
-                        chain_id: chainId,
-                        typed_data: typedData,
-                    }));
-                }
-                default:
-                    throw new Error(`CubistProvider: unsupported RPC method "${payload.method}"`);
-            }
-        },
-        async disconnect() {
-            await session.client.revokeSession();
-        },
-    };
-};

package/dist/providers/social/cubistProvider.d.ts

@@ -1,52 +0,0 @@
-import { AbstractSocialProvider, type SocialLoginOptions } from "./baseSocialProvider.js";
-import type { WalletConnectArgs, WalletSession } from "../../core/types.js";
-import { CubeSignerAuth, type CubeSignerConfig, type CubeSignerSession, type TwitterCodeExchangeParams } from "./cubeSignerAuth.js";
-export type CubistLoginMethod = {
-    type: "google";
-    idToken: string;
-} | {
-    type: "twitter";
-    params: TwitterCodeExchangeParams;
-};
-export interface CubistSessionAdapter {
-    /**
-     * Convert a raw CubeSigner session into a WalletSession
-     * (resolve the first key's address, chain, build a provider, etc.).
-     */
-    resolve(session: CubeSignerSession): Promise<WalletSession>;
-}
-export declare class CubistSocialProvider extends AbstractSocialProvider {
-    readonly id = "cubist";
-    readonly title = "Cubist Social Wallet";
-    private auth;
-    private adapter;
-    private lastCubeSignerSession;
-    /** Stash the login method so `connect()` can auto-retry. */
-    private lastLogin;
-    constructor(config: CubeSignerConfig, adapter?: CubistSessionAdapter);
-    private createWalletSession;
-    private authenticate;
-    private getResolvedLoginMethod;
-    /**
-     * Preferred explicit sign-in entrypoint.
-     */
-    signInWith(method: CubistLoginMethod, _options?: SocialLoginOptions): Promise<void>;
-    /**
-     * Backward-compatible abstract implementation.
-     *
-     * - If `payload` is provided, it is treated as the login method.
-     * - Otherwise reuses the previously cached login method if available.
-     */
-    signIn(_options?: SocialLoginOptions, payload?: unknown): Promise<void>;
-    /**
-     * Explicit connect flow that both authenticates and returns the wallet session.
-     */
-    connectWith(method: CubistLoginMethod, options?: SocialLoginOptions): Promise<WalletSession>;
-    connect(args?: WalletConnectArgs): Promise<WalletSession>;
-    reconnect(persistedSession: WalletSession): Promise<WalletSession | null>;
-    signOut(): Promise<void>;
-    disconnect(): Promise<void>;
-    /** Direct access to the underlying CubeSignerAuth for advanced use-cases. */
-    get cubeSignerAuth(): CubeSignerAuth;
-    get cubeSignerSession(): CubeSignerSession | null;
-}

package/dist/providers/social/cubistProvider.js

@@ -1,160 +0,0 @@
-import { AbstractSocialProvider } from "./baseSocialProvider.js";
-import { createSessionCapabilityPolicy, } from "../../core/capabilities.js";
-import { createChainContext } from "../../core/chains.js";
-import { CubeSignerAuth, } from "./cubeSignerAuth.js";
-import { createCubistEvmWalletProvider } from "./cubistEvmWalletProvider.js";
-/**
- * Default adapter — returns the first Secp256k1.Evm key's material ID
- * as the address on the ETH chain with an EVM-capable WalletProvider.
- */
-const defaultAdapter = {
-    async resolve(session) {
-        const keys = await session.client.sessionKeys();
-        const evmKey = keys.find((k) => k.cached.key_type === "SecpEthAddr");
-        if (!evmKey)
-            throw new Error("No EVM key found in CubeSigner session");
-        const address = evmKey.materialId;
-        const chain = "ETH";
-        const provider = createCubistEvmWalletProvider({
-            session,
-            address,
-            chain,
-        });
-        return {
-            address,
-            chain,
-            provider,
-            chainContext: createChainContext(chain),
-        };
-    },
-};
-const cubistCapabilities = [
-    "eth_accounts",
-    "eth_requestAccounts",
-    "eth_chainId",
-    "eth_signTransaction",
-    "personal_sign",
-    "eth_signTypedData_v4",
-    "wallet_disconnect",
-    "wallet_rehydrate",
-];
-/* ─── Provider ──────────────────────────────── */
-export class CubistSocialProvider extends AbstractSocialProvider {
-    constructor(config, adapter = defaultAdapter) {
-        super();
-        this.id = "cubist";
-        this.title = "Cubist Social Wallet";
-        this.lastCubeSignerSession = null;
-        /** Stash the login method so `connect()` can auto-retry. */
-        this.lastLogin = null;
-        this.auth = new CubeSignerAuth(config);
-        this.adapter = adapter;
-    }
-    async createWalletSession(method) {
-        const session = method.type === "google"
-            ? await this.auth.loginWithGoogle(method.idToken)
-            : await this.auth.loginWithTwitter(method.params);
-        this.lastCubeSignerSession = session;
-        const walletSession = await this.adapter.resolve(session);
-        const capabilityPolicy = this.auth.defaultSessionPolicy
-            ? createSessionCapabilityPolicy(this.auth.defaultSessionPolicy)
-            : undefined;
-        return {
-            ...walletSession,
-            walletType: "social",
-            authSource: method.type,
-            sessionId: `${method.type}:${walletSession.address.toLowerCase()}`,
-            expiresAt: capabilityPolicy?.expiresAt,
-            capabilities: cubistCapabilities,
-            sessionData: session.sessionData,
-            chainContext: walletSession.chainContext ?? createChainContext(walletSession.chain),
-            capabilityPolicy,
-        };
-    }
-    async authenticate(method) {
-        const walletSession = await this.createWalletSession(method);
-        this.lastLogin = method;
-        this.setSession(walletSession);
-    }
-    getResolvedLoginMethod(payload) {
-        const method = payload ?? this.lastLogin;
-        if (!method) {
-            throw new Error("CubistSocialProvider.signIn requires a login method. Use signInWith(method) first.");
-        }
-        return method;
-    }
-    /**
-     * Preferred explicit sign-in entrypoint.
-     */
-    async signInWith(method, _options) {
-        await this.authenticate(method);
-    }
-    /**
-     * Backward-compatible abstract implementation.
-     *
-     * - If `payload` is provided, it is treated as the login method.
-     * - Otherwise reuses the previously cached login method if available.
-     */
-    async signIn(_options, payload) {
-        await this.authenticate(this.getResolvedLoginMethod(payload));
-    }
-    /**
-     * Explicit connect flow that both authenticates and returns the wallet session.
-     */
-    async connectWith(method, options) {
-        return this.connect({ options, payload: method });
-    }
-    async connect(args) {
-        if (args?.payload !== undefined || args?.options !== undefined) {
-            await this.signIn(args.options, args.payload);
-            return this.requireSession("Cubist session missing after sign-in");
-        }
-        if (this.session) {
-            return this.session;
-        }
-        if (!this.lastLogin) {
-            throw new Error("Cubist session missing — call signInWith(method) first");
-        }
-        await this.signIn();
-        return this.requireSession("Cubist session missing after sign-in");
-    }
-    async reconnect(persistedSession) {
-        if (!persistedSession.sessionData)
-            return null;
-        try {
-            const csSession = await this.auth.restoreSession(persistedSession.sessionData);
-            this.lastCubeSignerSession = csSession;
-            const walletSession = await this.adapter.resolve(csSession);
-            return this.setSession({
-                ...walletSession,
-                walletType: persistedSession.walletType ?? "social",
-                authSource: persistedSession.authSource,
-                sessionId: persistedSession.sessionId,
-                expiresAt: persistedSession.expiresAt,
-                capabilities: cubistCapabilities,
-                sessionData: csSession.sessionData,
-                chainContext: walletSession.chainContext ?? createChainContext(walletSession.chain),
-                capabilityPolicy: persistedSession.capabilityPolicy,
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    async signOut() {
-        await this.auth.signOut();
-        this.clearSession();
-        this.lastLogin = null;
-        this.lastCubeSignerSession = null;
-    }
-    async disconnect() {
-        await this.signOut();
-    }
-    /** Direct access to the underlying CubeSignerAuth for advanced use-cases. */
-    get cubeSignerAuth() {
-        return this.auth;
-    }
-    get cubeSignerSession() {
-        return this.lastCubeSignerSession ?? this.auth.currentSession;
-    }
-}