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

package/dist/chunk-MVZIAM4H.js

@@ -0,0 +1,363 @@
+import { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-5HURLKIK.js';
+
+// src/core/chains.ts
+var 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
+  }
+};
+var getChainDescriptor = (chain) => chainDescriptors[chain];
+var getAllChainDescriptors = () => Object.values(chainDescriptors);
+var normalizeEvmChainId = (value) => {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  return Number(BigInt(value));
+};
+var 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;
+};
+var createChainContext = (walletChain, settlementChain = walletChain) => ({
+  walletChain,
+  walletChainDescriptor: getChainDescriptor(walletChain),
+  settlementChain,
+  settlementChainDescriptor: getChainDescriptor(settlementChain)
+});
+
+// src/core/capabilities.ts
+var SessionCapabilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionCapabilityError";
+  }
+};
+var toBigIntAmount = (value) => {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(value);
+  return BigInt(value);
+};
+var 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
+});
+var isSessionExpired = (session, now = Date.now()) => Boolean(session?.expiresAt && session.expiresAt <= now);
+var isCapabilityPolicyExpired = (policy, now = Date.now()) => Boolean(policy?.expiresAt && policy.expiresAt <= now);
+var sessionSupportsCapability = (session, capability) => {
+  const capabilities = session?.capabilities;
+  if (!capabilities || capabilities.length === 0) return true;
+  return capabilities.includes(capability);
+};
+var 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;
+};
+var 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 !== void 0) {
+    if (toBigIntAmount(check.amount) > toBigIntAmount(policy.maxAmount)) {
+      throw new SessionCapabilityError("Requested amount exceeds the capability session limit");
+    }
+  }
+};
+
+// src/providers/base.ts
+var AbstractProvider = class {
+  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;
+  }
+};
+
+// src/providers/social/baseSocialProvider.ts
+var AbstractSocialProvider = class extends AbstractProvider {
+  constructor() {
+    super(...arguments);
+    this.category = "social";
+  }
+  async connect(args) {
+    await this.signIn(args?.options, args?.payload);
+    return this.requireSession();
+  }
+};
+
+// src/providers/social/cubistProvider.ts
+var 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)
+    };
+  }
+};
+var cubistCapabilities = [
+  "eth_accounts",
+  "eth_requestAccounts",
+  "eth_chainId",
+  "eth_signTransaction",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "wallet_disconnect",
+  "wallet_rehydrate"
+];
+var CubistSocialProvider = class 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) : void 0;
+    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 !== void 0 || args?.options !== void 0) {
+      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 \u2014 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;
+  }
+};
+
+export { AbstractProvider, AbstractSocialProvider, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createChainContext, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability };