@orbi-wallet/sdk 0.1.2 → 0.1.4

package/dist/client.d.ts

@@ -8,10 +8,11 @@
  *   const { walletAddress } = await orbi.connect();
  *   const { signedXdr } = await orbi.signTransaction({ xdr });
  */
-import type { ConnectedWallet, EvmSignResult, OrbiChain, OrbiClientConfig, SignResult } from './types';
+import type { ConnectedWallet, EvmSignatureResult, EvmSignResult, EvmTxParams, OrbiChain, OrbiClientConfig, SignResult } from './types';
 export declare class OrbiClient {
     private network;
     private chain;
+    private chainId?;
     constructor(config?: OrbiClientConfig);
     /** Wallet address from a previous `connect()`, restored from local storage. */
     getAddress(): string | null;
@@ -40,14 +41,29 @@ export declare class OrbiClient {
         walletAddress?: string;
     }): Promise<SignResult>;
     /**
-     * Ask the user to review and approve a native-token (BOT) transfer on
-     * BotChain. Signing and submission happen inside the Orbi popup — where the
-     * passkey lives — so the dApp never touches a key. Returns the tx hash.
+     * Review and approve an EVM transaction — native transfer or contract call.
+     * Signing and submission happen inside the Orbi popup (where the passkey
+     * lives), so the dApp never touches a key. Returns the tx hash.
+     * `value` is wei (decimal string); `data` is 0x calldata for contract calls.
      */
-    signEvmTransaction(params: {
-        to: string;
-        value: string;
+    signEvmTransaction(params: EvmTxParams): Promise<EvmSignResult>;
+    /**
+     * Sign an arbitrary message (EIP-191 / personal_sign). This is what dApp
+     * login ("Sign-In With Ethereum") uses. Returns the 65-byte signature.
+     */
+    signMessage(params: {
+        message: string;
+        chainId?: number;
+        walletAddress?: string;
+    }): Promise<EvmSignatureResult>;
+    /**
+     * Sign EIP-712 typed data (eth_signTypedData_v4) — permits, listings, etc.
+     * `typedData` is the standard { domain, types, primaryType, message } object.
+     */
+    signTypedData(params: {
+        typedData: unknown;
+        chainId?: number;
         walletAddress?: string;
-    }): Promise<EvmSignResult>;
+    }): Promise<EvmSignatureResult>;
     private openPopup;
 }

package/dist/client.js

@@ -23,6 +23,7 @@ class OrbiClient {
     constructor(config = {}) {
         this.network = config.network ?? 'testnet';
         this.chain = config.chain ?? 'stellar';
+        this.chainId = config.chainId;
     }
     // ── Session ─────────────────────────────────────────────────────────────────
     /** Wallet address from a previous `connect()`, restored from local storage. */
@@ -108,19 +109,26 @@ class OrbiClient {
         });
     }
     /**
-     * Ask the user to review and approve a native-token (BOT) transfer on
-     * BotChain. Signing and submission happen inside the Orbi popup — where the
-     * passkey lives — so the dApp never touches a key. Returns the tx hash.
+     * Review and approve an EVM transaction — native transfer or contract call.
+     * Signing and submission happen inside the Orbi popup (where the passkey
+     * lives), so the dApp never touches a key. Returns the tx hash.
+     * `value` is wei (decimal string); `data` is 0x calldata for contract calls.
      */
     signEvmTransaction(params) {
         const walletAddress = params.walletAddress ?? this.getAddress() ?? undefined;
+        const chainId = params.chainId ?? this.chainId;
+        if (chainId === undefined)
+            throw new Error('chainId is required for EVM transactions');
         return this.openPopup({
             path: '/sign',
             params: {
                 chain: 'botchain',
+                evmAction: 'tx',
+                chainId: String(chainId),
                 to: params.to,
-                value: params.value,
-                network: this.network,
+                ...(params.value ? { value: params.value } : {}),
+                ...(params.data ? { data: params.data } : {}),
+                ...(params.gas ? { gas: params.gas } : {}),
                 ...(walletAddress ? { walletAddress } : {}),
             },
             successType: 'orbi_evm_sent',
@@ -130,6 +138,52 @@ class OrbiClient {
             }),
         });
     }
+    /**
+     * Sign an arbitrary message (EIP-191 / personal_sign). This is what dApp
+     * login ("Sign-In With Ethereum") uses. Returns the 65-byte signature.
+     */
+    signMessage(params) {
+        const walletAddress = params.walletAddress ?? this.getAddress() ?? undefined;
+        const chainId = params.chainId ?? this.chainId;
+        return this.openPopup({
+            path: '/sign',
+            params: {
+                chain: 'botchain',
+                evmAction: 'message',
+                message: params.message,
+                ...(chainId !== undefined ? { chainId: String(chainId) } : {}),
+                ...(walletAddress ? { walletAddress } : {}),
+            },
+            successType: 'orbi_evm_signed',
+            mapSuccess: (msg) => ({
+                signature: msg.signature,
+                walletAddress: msg.walletAddress,
+            }),
+        });
+    }
+    /**
+     * Sign EIP-712 typed data (eth_signTypedData_v4) — permits, listings, etc.
+     * `typedData` is the standard { domain, types, primaryType, message } object.
+     */
+    signTypedData(params) {
+        const walletAddress = params.walletAddress ?? this.getAddress() ?? undefined;
+        const chainId = params.chainId ?? this.chainId;
+        return this.openPopup({
+            path: '/sign',
+            params: {
+                chain: 'botchain',
+                evmAction: 'typedData',
+                typedData: JSON.stringify(params.typedData),
+                ...(chainId !== undefined ? { chainId: String(chainId) } : {}),
+                ...(walletAddress ? { walletAddress } : {}),
+            },
+            successType: 'orbi_evm_signed',
+            mapSuccess: (msg) => ({
+                signature: msg.signature,
+                walletAddress: msg.walletAddress,
+            }),
+        });
+    }
     // ── Popup + postMessage handshake ───────────────────────────────────────────
     openPopup(req) {
         if (typeof window === 'undefined') {

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export { OrbiClient } from './client';
-export type { ConnectedWallet, EvmSignResult, OrbiChain, OrbiClientConfig, OrbiNetwork, SignResult } from './types';
+export { OrbiEIP1193Provider, createOrbiProvider } from './provider';
+export type { OrbiProviderChain, OrbiProviderConfig } from './provider';
+export type { ConnectedWallet, EvmSignatureResult, EvmSignResult, EvmTxParams, OrbiChain, OrbiClientConfig, OrbiNetwork, SignResult } from './types';

package/dist/index.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrbiClient = void 0;
+exports.createOrbiProvider = exports.OrbiEIP1193Provider = exports.OrbiClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "OrbiClient", { enumerable: true, get: function () { return client_1.OrbiClient; } });
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "OrbiEIP1193Provider", { enumerable: true, get: function () { return provider_1.OrbiEIP1193Provider; } });
+Object.defineProperty(exports, "createOrbiProvider", { enumerable: true, get: function () { return provider_1.createOrbiProvider; } });

package/dist/provider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * EIP-1193 provider for Orbi (EVM).
+ *
+ * Wraps OrbiClient so any standard EVM tooling — wagmi, ethers, viem,
+ * RainbowKit — can talk to an Orbi passkey wallet through the universal
+ * `request({ method, params })` interface. Signing methods open the Orbi popup
+ * (where the passkey lives); read methods are proxied to the chain's RPC.
+ */
+import { OrbiClient } from './client';
+import type { OrbiNetwork } from './types';
+export interface OrbiProviderChain {
+    chainId: number;
+    rpcUrl: string;
+}
+export interface OrbiProviderConfig {
+    /** EVM chains this provider can serve, each with a JSON-RPC URL. */
+    chains: OrbiProviderChain[];
+    /** Active chain on construction. Defaults to the first chain. */
+    defaultChainId?: number;
+    network?: OrbiNetwork;
+    /** Reuse an existing client (and its session); one is created otherwise. */
+    client?: OrbiClient;
+}
+interface RequestArgs {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+type Listener = (...args: unknown[]) => void;
+export declare class OrbiEIP1193Provider {
+    /** Lets dApps detect Orbi specifically (à la `isMetaMask`). */
+    readonly isOrbi = true;
+    private client;
+    private chains;
+    private chainId;
+    private listeners;
+    constructor(config: OrbiProviderConfig);
+    on(event: string, fn: Listener): this;
+    removeListener(event: string, fn: Listener): this;
+    private emit;
+    private currentAccounts;
+    request(args: RequestArgs): Promise<unknown>;
+    private rpc;
+    /** Convenience: forget the cached session (next eth_requestAccounts re-prompts). */
+    disconnect(): void;
+}
+export declare function createOrbiProvider(config: OrbiProviderConfig): OrbiEIP1193Provider;
+export {};

package/dist/provider.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * EIP-1193 provider for Orbi (EVM).
+ *
+ * Wraps OrbiClient so any standard EVM tooling — wagmi, ethers, viem,
+ * RainbowKit — can talk to an Orbi passkey wallet through the universal
+ * `request({ method, params })` interface. Signing methods open the Orbi popup
+ * (where the passkey lives); read methods are proxied to the chain's RPC.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrbiEIP1193Provider = void 0;
+exports.createOrbiProvider = createOrbiProvider;
+const client_1 = require("./client");
+function providerError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+// SDK popup rejections → EIP-1193's standard "user rejected" code (4001).
+function mapRejection(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/cancel|closed|reject/i.test(msg))
+        throw providerError(4001, 'User rejected the request');
+    throw err;
+}
+const isAddress = (v) => typeof v === 'string' && /^0x[0-9a-fA-F]{40}$/.test(v);
+const toHexNum = (n) => '0x' + n.toString(16);
+class OrbiEIP1193Provider {
+    constructor(config) {
+        /** Lets dApps detect Orbi specifically (à la `isMetaMask`). */
+        this.isOrbi = true;
+        this.listeners = {};
+        if (!config.chains?.length)
+            throw new Error('OrbiProvider requires at least one chain');
+        this.chains = new Map(config.chains.map((c) => [c.chainId, c.rpcUrl]));
+        this.chainId = config.defaultChainId ?? config.chains[0].chainId;
+        if (!this.chains.has(this.chainId))
+            throw new Error(`No RPC configured for chain ${this.chainId}`);
+        this.client =
+            config.client ?? new client_1.OrbiClient({ network: config.network, chain: 'botchain', chainId: this.chainId });
+    }
+    // ── EIP-1193 events ──────────────────────────────────────────────────────────
+    on(event, fn) { var _a; ((_a = this.listeners)[event] ?? (_a[event] = [])).push(fn); return this; }
+    removeListener(event, fn) {
+        this.listeners[event] = (this.listeners[event] ?? []).filter((l) => l !== fn);
+        return this;
+    }
+    emit(event, ...args) {
+        (this.listeners[event] ?? []).forEach((l) => l(...args));
+    }
+    currentAccounts() {
+        const addr = this.client.getAddress();
+        return addr && this.client.getChain() === 'botchain' ? [addr] : [];
+    }
+    // ── EIP-1193 request ─────────────────────────────────────────────────────────
+    async request(args) {
+        const { method } = args;
+        const params = (Array.isArray(args.params) ? args.params : []);
+        switch (method) {
+            case 'eth_requestAccounts': {
+                try {
+                    const { walletAddress } = await this.client.connect({ chain: 'botchain' });
+                    this.emit('connect', { chainId: toHexNum(this.chainId) });
+                    this.emit('accountsChanged', [walletAddress]);
+                    return [walletAddress];
+                }
+                catch (err) {
+                    return mapRejection(err);
+                }
+            }
+            case 'eth_accounts':
+                return this.currentAccounts();
+            case 'eth_chainId':
+                return toHexNum(this.chainId);
+            case 'net_version':
+                return String(this.chainId);
+            case 'wallet_getPermissions':
+            case 'wallet_requestPermissions':
+                return [{ parentCapability: 'eth_accounts' }];
+            case 'wallet_switchEthereumChain': {
+                const target = parseInt(params[0]?.chainId, 16);
+                if (!this.chains.has(target)) {
+                    throw providerError(4902, `Chain ${target} not configured in Orbi provider`);
+                }
+                this.chainId = target;
+                this.emit('chainChanged', toHexNum(target));
+                return null;
+            }
+            case 'wallet_addEthereumChain': {
+                const target = parseInt(params[0]?.chainId, 16);
+                if (!this.chains.has(target))
+                    throw providerError(4902, `Chain ${target} not supported by Orbi`);
+                return null;
+            }
+            case 'eth_sendTransaction': {
+                const tx = (params[0] ?? {});
+                try {
+                    const { txHash } = await this.client.signEvmTransaction({
+                        to: tx.to,
+                        value: tx.value ? BigInt(tx.value).toString() : undefined,
+                        data: tx.data,
+                        gas: tx.gas ? BigInt(tx.gas).toString() : undefined,
+                        chainId: this.chainId,
+                    });
+                    return txHash;
+                }
+                catch (err) {
+                    return mapRejection(err);
+                }
+            }
+            case 'personal_sign': {
+                // params: [message, address] (order varies by dApp — detect the address)
+                const message = (isAddress(params[0]) ? params[1] : params[0]);
+                try {
+                    const { signature } = await this.client.signMessage({ message, chainId: this.chainId });
+                    return signature;
+                }
+                catch (err) {
+                    return mapRejection(err);
+                }
+            }
+            case 'eth_signTypedData_v4': {
+                // params: [address, typedData]
+                const raw = (isAddress(params[0]) ? params[1] : params[0]);
+                const typedData = typeof raw === 'string' ? JSON.parse(raw) : raw;
+                try {
+                    const { signature } = await this.client.signTypedData({ typedData, chainId: this.chainId });
+                    return signature;
+                }
+                catch (err) {
+                    return mapRejection(err);
+                }
+            }
+            case 'eth_sign':
+            case 'eth_signTypedData':
+            case 'eth_signTypedData_v3':
+                throw providerError(4200, `${method} is not supported — use personal_sign or eth_signTypedData_v4`);
+            // Everything else (eth_call, eth_getBalance, eth_estimateGas,
+            // eth_getTransactionReceipt, eth_blockNumber, …) is a read — proxy to RPC.
+            default:
+                return this.rpc(method, params);
+        }
+    }
+    async rpc(method, params) {
+        const url = this.chains.get(this.chainId);
+        if (!url)
+            throw providerError(4901, `No RPC for chain ${this.chainId}`);
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method, params }),
+        });
+        const json = (await res.json());
+        if (json.error)
+            throw providerError(json.error.code ?? -32000, json.error.message ?? 'RPC error');
+        return json.result;
+    }
+    /** Convenience: forget the cached session (next eth_requestAccounts re-prompts). */
+    disconnect() {
+        this.client.disconnect();
+        this.emit('disconnect');
+        this.emit('accountsChanged', []);
+    }
+}
+exports.OrbiEIP1193Provider = OrbiEIP1193Provider;
+function createOrbiProvider(config) {
+    return new OrbiEIP1193Provider(config);
+}

package/dist/types.d.ts

@@ -6,6 +6,8 @@ export interface OrbiClientConfig {
     network?: OrbiNetwork;
     /** Chain to connect on. Defaults to 'stellar'. */
     chain?: OrbiChain;
+    /** Default EVM chainId for signing/sending (per-call override available). */
+    chainId?: number;
 }
 export interface ConnectedWallet {
     walletAddress: string;
@@ -27,3 +29,15 @@ export interface EvmSignResult {
     txHash: string;
     walletAddress: string;
 }
+export interface EvmSignatureResult {
+    signature: string;
+    walletAddress: string;
+}
+export interface EvmTxParams {
+    to: string;
+    value?: string;
+    data?: string;
+    gas?: string;
+    chainId?: number;
+    walletAddress?: string;
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 export declare const SDK_NAME = "@orbi-wallet/sdk";
-export declare const SDK_VERSION = "0.1.2";
+export declare const SDK_VERSION = "0.1.4";

package/dist/version.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = exports.SDK_NAME = void 0;
 // Generated by scripts/generate-version.js from package.json — do not edit.
 exports.SDK_NAME = "@orbi-wallet/sdk";
-exports.SDK_VERSION = "0.1.2";
+exports.SDK_VERSION = "0.1.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbi-wallet/sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Orbi Smart Wallet SDK — connect any Stellar or BotChain dApp to Orbi passkey wallets",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",