@swivy/viem 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @swivy/viem
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Swivy viem SDK. Testnet preview; production onboarding is gated on the Swop canary.
+
+Public npm distribution is being prepared. Before first publication, use all SDK tarballs
+from one operator-supplied release and verify its SHA256SUMS. After publication:
+
+```sh
+npm install @swivy/viem@next
+```
+
+Use an environment app ID and publishable key for browser/mobile apps. Keep environment
+secret keys on the backend and deployment bootstrap credentials with the deployment operator.
+Choose email or SMS in your environment policy; SMS recovery alone does not enable SMS login.
+Never log login codes, runtime sessions or signing material.
+
+Browser apps currently need a same-origin reverse proxy for `/v1/runtime/*`; the API
+does not advertise cross-origin browser access. Backend and native clients can use the API directly.
+
+Requires viem 2. Use the adapter with an authenticated Swivy runtime session and owner-approved signing policy.

package/dist/packages/viem/src/index.d.ts

@@ -0,0 +1,111 @@
+import type { TransactionIntent } from "@swivy/core";
+import { type Address, type LocalAccount, type SignableMessage, type TransactionSerializable, type TypedDataDefinition } from "viem";
+export interface SwivyViemWaitOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * The subset of `SwivyBrowserClient` (from `@swivy/web`) that `toSwivyViemAccount` needs.
+ * Any object with the same method works (a server-side wrapper, a test fake, ...).
+ */
+export interface SwivyViemSigningClient {
+    createSigningIntentAndWait(body: Record<string, unknown>, options?: SwivyViemWaitOptions): Promise<TransactionIntent>;
+}
+/** The subset of `SwivyBrowserClient` that `createSwivyEip1193Provider` needs. */
+export interface SwivyViemClient extends SwivyViemSigningClient {
+    createTransactionIntentAndWait(body: Record<string, unknown>, options?: SwivyViemWaitOptions): Promise<TransactionIntent>;
+}
+/** A managed EVM account, e.g. a `ManagedAccountDescriptor` from `listEmbeddedWallets()`. */
+export interface SwivyViemManagedAccount {
+    id: string;
+    address: string;
+}
+export type SwivySigningOperation = "signMessage" | "signTypedData" | "signTransaction" | "sendTransaction";
+export interface SwivyChallengeContext {
+    operation: SwivySigningOperation;
+    accountId: string;
+    address: Address;
+    chainId?: number;
+    network?: string | null;
+}
+/**
+ * Returns a verified MFA `challengeId` (e.g. from `client.approveWithPasskey(...)`) when the
+ * environment's policy requires step-up, or `undefined`/`null` to send the intent without one.
+ */
+export type SwivyGetChallengeId = (context: SwivyChallengeContext) => Promise<string | null | undefined> | string | null | undefined;
+export interface SwivyViemAccountOptions {
+    getChallengeId?: SwivyGetChallengeId;
+    waitOptions?: SwivyViemWaitOptions;
+}
+export declare class SwivyViemSigningError extends Error {
+    readonly intentId: string | null;
+    constructor(message: string, intentId?: string | null);
+}
+/**
+ * Convert a viem transaction (bigints, `gas`, string `type`) or an EIP-1193 transaction request
+ * (hex quantities, `gas`, `input`) into the JSON shape the Swivy API signs with ethers:
+ * numeric `type`/`chainId`/`nonce`, hex-string quantities, and `gasLimit`.
+ */
+export declare function toSwivyTransactionPayload(transaction: Record<string, unknown> | TransactionSerializable): Record<string, unknown>;
+/** Build the Swivy `typedData` payload from viem `signTypedData` parameters. */
+export declare function toSwivyTypedDataPayload(typedData: TypedDataDefinition | Record<string, unknown>): Record<string, unknown>;
+/** Build the Swivy message payload: `message` for UTF-8 strings, `messageHex` for raw bytes. */
+export declare function toSwivyMessagePayload(message: SignableMessage): Record<string, string>;
+/**
+ * Swivy equivalent of Privy's `toViemAccount({ wallet })`. Every signature goes through a Swivy
+ * signing intent (policy, MFA and audit apply); nothing signs a raw digest.
+ */
+export declare function toSwivyViemAccount(client: SwivyViemSigningClient, account: SwivyViemManagedAccount, options?: SwivyViemAccountOptions): LocalAccount;
+export interface SwivyProviderChain {
+    id: number;
+    /** Swivy environment RPC target name, e.g. `base-mainnet`. Overrides the default map. */
+    network?: string;
+    /** Read-only JSON-RPC URL used for forwarded reads and transaction filling on this chain. */
+    rpcUrl?: string;
+}
+export interface SwivyEip1193ProviderOptions extends SwivyViemAccountOptions {
+    /** Chains the provider may switch to. Accepts viem `Chain` objects too (only `id` is read). */
+    chains: SwivyProviderChain[];
+    /** Initial chain. Defaults to the first configured chain. */
+    initialChainId?: number;
+    /** chainId -> Swivy network name. Merged over `DEFAULT_SWIVY_EVM_NETWORKS`. */
+    networks?: Record<number, string>;
+    /** Fallback read-only RPC URL (or per-chain map) when a chain has no `rpcUrl`. */
+    rpcUrl?: string | Record<number, string>;
+    /** Fill nonce, gas and fees from the RPC before `eth_sendTransaction`. Default true. */
+    fillTransactions?: boolean;
+    /** Ask the API to sponsor gas for `eth_sendTransaction` (needs sponsorship configured). */
+    sponsorshipRequested?: boolean;
+    fetch?: typeof fetch;
+}
+/** Chain id to Swivy environment RPC target names (see `tools/rpc-presets.mjs`). */
+export declare const DEFAULT_SWIVY_EVM_NETWORKS: Readonly<Record<number, string>>;
+export interface SwivyEip1193RequestArguments {
+    method: string;
+    params?: readonly unknown[] | Record<string, unknown>;
+}
+type Listener = (...args: any[]) => void;
+export interface SwivyEip1193Provider {
+    request(args: SwivyEip1193RequestArguments): Promise<any>;
+    on(event: string, listener: Listener): SwivyEip1193Provider;
+    removeListener(event: string, listener: Listener): SwivyEip1193Provider;
+    /** The viem account backing this provider (signs through Swivy intents). */
+    readonly account: LocalAccount;
+    readonly chainId: number;
+    /** Swap the managed account (e.g. after login) and emit `accountsChanged`. */
+    setAccount(account: SwivyViemManagedAccount | null): void;
+    /** Disconnect: emits `accountsChanged` with `[]` and `disconnect`. */
+    disconnect(): void;
+}
+export declare class SwivyProviderRpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/**
+ * EIP-1193 provider backed by a Swivy managed EVM account. Plug it into wagmi with the built-in
+ * `injected({ target: () => ({ id: "swivy", name: "Swivy", provider }) })` connector.
+ */
+export declare function createSwivyEip1193Provider(client: SwivyViemClient, account: SwivyViemManagedAccount, options: SwivyEip1193ProviderOptions): SwivyEip1193Provider;
+export {};

package/dist/packages/viem/src/index.js

@@ -0,0 +1,485 @@
+import { getAddress, isAddressEqual, isHex, numberToHex, toHex, } from "viem";
+import { toAccount } from "viem/accounts";
+export class SwivyViemSigningError extends Error {
+    intentId;
+    constructor(message, intentId = null) {
+        super(message);
+        this.name = "SwivyViemSigningError";
+        this.intentId = intentId;
+    }
+}
+/* -------------------------------------------------------------------------------------------------
+ * Serialization helpers
+ * -----------------------------------------------------------------------------------------------*/
+const TRANSACTION_TYPE_NUMBERS = {
+    legacy: 0,
+    eip2930: 1,
+    eip1559: 2,
+    eip4844: 3,
+    eip7702: 4,
+};
+function quantityToHex(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "bigint" || typeof value === "number") {
+        return numberToHex(value);
+    }
+    if (typeof value === "string") {
+        return numberToHex(BigInt(value));
+    }
+    throw new SwivyViemSigningError("invalid_quantity");
+}
+function quantityToNumber(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "bigint" || typeof value === "string") {
+        return Number(BigInt(value));
+    }
+    throw new SwivyViemSigningError("invalid_quantity");
+}
+function transactionTypeToNumber(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        if (value in TRANSACTION_TYPE_NUMBERS) {
+            return TRANSACTION_TYPE_NUMBERS[value];
+        }
+        if (isHex(value) || /^\d+$/.test(value)) {
+            return Number(BigInt(value));
+        }
+    }
+    throw new SwivyViemSigningError("unsupported_transaction_type");
+}
+/**
+ * Convert a viem transaction (bigints, `gas`, string `type`) or an EIP-1193 transaction request
+ * (hex quantities, `gas`, `input`) into the JSON shape the Swivy API signs with ethers:
+ * numeric `type`/`chainId`/`nonce`, hex-string quantities, and `gasLimit`.
+ */
+export function toSwivyTransactionPayload(transaction) {
+    const tx = transaction;
+    if (tx.blobs !== undefined || tx.sidecars !== undefined || tx.authorizationList !== undefined) {
+        throw new SwivyViemSigningError("unsupported_transaction_fields");
+    }
+    const payload = {
+        type: transactionTypeToNumber(tx.type),
+        chainId: quantityToNumber(tx.chainId),
+        nonce: quantityToNumber(tx.nonce),
+        to: tx.to ?? undefined,
+        value: quantityToHex(tx.value),
+        data: (tx.data ?? tx.input),
+        gasLimit: quantityToHex(tx.gas ?? tx.gasLimit),
+        gasPrice: quantityToHex(tx.gasPrice),
+        maxFeePerGas: quantityToHex(tx.maxFeePerGas),
+        maxPriorityFeePerGas: quantityToHex(tx.maxPriorityFeePerGas),
+        accessList: tx.accessList,
+    };
+    return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
+}
+/** JSON-safe deep copy: bigints become decimal strings, byte arrays become hex. */
+function toJsonSafe(value) {
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Uint8Array) {
+        return toHex(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(toJsonSafe);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .map(([key, entry]) => [key, toJsonSafe(entry)]));
+    }
+    return value;
+}
+/** Build the Swivy `typedData` payload from viem `signTypedData` parameters. */
+export function toSwivyTypedDataPayload(typedData) {
+    const definition = typedData;
+    return toJsonSafe({
+        domain: definition.domain ?? {},
+        types: definition.types,
+        primaryType: definition.primaryType ?? null,
+        message: definition.message ?? {},
+    });
+}
+/** Build the Swivy message payload: `message` for UTF-8 strings, `messageHex` for raw bytes. */
+export function toSwivyMessagePayload(message) {
+    if (typeof message === "string") {
+        return { message };
+    }
+    const raw = message.raw;
+    return { messageHex: typeof raw === "string" ? raw : toHex(raw) };
+}
+function intentFailure(intent, fallback) {
+    return new SwivyViemSigningError(intent.result?.error ?? fallback, intent.id ?? null);
+}
+function requireSignature(intent) {
+    const signature = intent.result?.signature;
+    if (intent.status !== "completed" || !signature) {
+        throw intentFailure(intent, "swivy_signing_failed");
+    }
+    return signature;
+}
+async function resolveChallengeId(getChallengeId, context) {
+    if (!getChallengeId) {
+        return {};
+    }
+    const challengeId = await getChallengeId(context);
+    return challengeId ? { challengeId } : {};
+}
+/* -------------------------------------------------------------------------------------------------
+ * toSwivyViemAccount
+ * -----------------------------------------------------------------------------------------------*/
+/**
+ * Swivy equivalent of Privy's `toViemAccount({ wallet })`. Every signature goes through a Swivy
+ * signing intent (policy, MFA and audit apply); nothing signs a raw digest.
+ */
+export function toSwivyViemAccount(client, account, options = {}) {
+    const address = getAddress(account.address);
+    async function sign(operation, payload, chainId) {
+        const challenge = await resolveChallengeId(options.getChallengeId, {
+            operation,
+            accountId: account.id,
+            address,
+            chainId,
+        });
+        const intent = await client.createSigningIntentAndWait({
+            accountId: account.id,
+            chain: "evm",
+            ...challenge,
+            payload,
+        }, options.waitOptions);
+        return intent;
+    }
+    return toAccount({
+        address,
+        async signMessage({ message }) {
+            return requireSignature(await sign("signMessage", toSwivyMessagePayload(message)));
+        },
+        async signTypedData(typedData) {
+            const definition = typedData;
+            const domain = definition.domain;
+            return requireSignature(await sign("signTypedData", { typedData: toSwivyTypedDataPayload(definition) }, quantityToNumber(domain?.chainId)));
+        },
+        // viem passes `{ serializer }` for chains with custom formats (e.g. OP-stack deposit txs).
+        // Swivy signs standard EIP-155/2718 envelopes, which those chains accept for normal txs.
+        async signTransaction(transaction) {
+            const payload = toSwivyTransactionPayload(transaction);
+            const intent = await sign("signTransaction", { transaction: payload }, payload.chainId);
+            const signed = intent.result?.signedPayload ?? intent.result?.signature;
+            if (intent.status !== "completed" || !signed) {
+                throw intentFailure(intent, "swivy_signing_failed");
+            }
+            return signed;
+        },
+    });
+}
+/** Chain id to Swivy environment RPC target names (see `tools/rpc-presets.mjs`). */
+export const DEFAULT_SWIVY_EVM_NETWORKS = Object.freeze({
+    1: "ethereum-mainnet",
+    10: "optimism-mainnet",
+    137: "polygon-mainnet",
+    8453: "base-mainnet",
+    42161: "arbitrum-mainnet",
+    84532: "base-sepolia",
+});
+export class SwivyProviderRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = "SwivyProviderRpcError";
+        this.code = code;
+        this.data = data;
+    }
+}
+const UNSUPPORTED_SIGNING_METHODS = new Set([
+    "eth_sign",
+    "eth_signTypedData",
+    "eth_signTypedData_v1",
+    "eth_signTypedData_v3",
+    "wallet_addEthereumChain",
+    "wallet_watchAsset",
+    "wallet_sendCalls",
+]);
+function paramsArray(params) {
+    if (params === undefined) {
+        return [];
+    }
+    return Array.isArray(params) ? [...params] : [params];
+}
+/**
+ * EIP-1193 provider backed by a Swivy managed EVM account. Plug it into wagmi with the built-in
+ * `injected({ target: () => ({ id: "swivy", name: "Swivy", provider }) })` connector.
+ */
+export function createSwivyEip1193Provider(client, account, options) {
+    if (!options.chains?.length) {
+        throw new Error("swivy_provider_requires_chains");
+    }
+    const chains = new Map(options.chains.map((chain) => [Number(chain.id), chain]));
+    const networks = { ...DEFAULT_SWIVY_EVM_NETWORKS, ...(options.networks ?? {}) };
+    const fetchFn = options.fetch ?? ((...args) => globalThis.fetch(...args));
+    const listeners = new Map();
+    let currentChainId = options.initialChainId ?? Number(options.chains[0].id);
+    if (!chains.has(currentChainId)) {
+        throw new Error("swivy_provider_initial_chain_not_configured");
+    }
+    let managedAccount = account;
+    let viemAccount = toSwivyViemAccount(client, account, options);
+    let rpcId = 0;
+    let connected = false;
+    function emit(event, ...args) {
+        for (const listener of listeners.get(event) ?? []) {
+            try {
+                listener(...args);
+            }
+            catch {
+                // Listener errors must not break the provider.
+            }
+        }
+    }
+    function networkFor(chainId) {
+        return chains.get(chainId)?.network ?? networks[chainId] ?? null;
+    }
+    function rpcUrlFor(chainId) {
+        const chain = chains.get(chainId);
+        if (chain?.rpcUrl) {
+            return chain.rpcUrl;
+        }
+        if (typeof options.rpcUrl === "string") {
+            return options.rpcUrl;
+        }
+        return options.rpcUrl?.[chainId] ?? null;
+    }
+    function requireAccount() {
+        if (!managedAccount) {
+            throw new SwivyProviderRpcError(4100, "Swivy account is not connected");
+        }
+        return managedAccount;
+    }
+    function assertOwnAddress(candidate) {
+        const own = requireAccount();
+        if (typeof candidate === "string" &&
+            candidate &&
+            !isAddressEqual(candidate, own.address)) {
+            throw new SwivyProviderRpcError(4100, "Requested address is not the connected Swivy account");
+        }
+    }
+    async function rpc(method, params) {
+        const url = rpcUrlFor(currentChainId);
+        if (!url) {
+            throw new SwivyProviderRpcError(4200, `Method not supported: ${method}`);
+        }
+        rpcId += 1;
+        const response = await fetchFn(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: rpcId, method, params }),
+        });
+        if (!response.ok) {
+            throw new SwivyProviderRpcError(-32603, `RPC request failed with status ${response.status}`);
+        }
+        const body = (await response.json());
+        if (body.error) {
+            throw new SwivyProviderRpcError(body.error.code ?? -32603, body.error.message ?? "RPC error", body.error.data);
+        }
+        return body.result;
+    }
+    async function fillTransaction(request, from) {
+        const tx = { ...request, chainId: currentChainId };
+        if (options.fillTransactions === false || !rpcUrlFor(currentChainId)) {
+            return tx;
+        }
+        if (tx.nonce === undefined) {
+            tx.nonce = await rpc("eth_getTransactionCount", [from, "pending"]);
+        }
+        if (tx.gas === undefined && tx.gasLimit === undefined) {
+            const { chainId: _chainId, nonce: _nonce, type: _type, ...estimateRequest } = tx;
+            tx.gas = await rpc("eth_estimateGas", [{ ...estimateRequest, from }]);
+        }
+        const hasFees = tx.gasPrice !== undefined || (tx.maxFeePerGas !== undefined && tx.maxPriorityFeePerGas !== undefined);
+        if (!hasFees) {
+            const block = (await rpc("eth_getBlockByNumber", ["latest", false]));
+            if (block?.baseFeePerGas && tx.type !== "0x0" && tx.type !== "legacy") {
+                const priority = tx.maxPriorityFeePerGas !== undefined
+                    ? BigInt(tx.maxPriorityFeePerGas)
+                    : BigInt((await rpc("eth_maxPriorityFeePerGas", [])));
+                tx.maxPriorityFeePerGas = numberToHex(priority);
+                tx.maxFeePerGas = tx.maxFeePerGas ?? numberToHex(BigInt(block.baseFeePerGas) * 2n + priority);
+                tx.type = tx.type ?? "0x2";
+            }
+            else {
+                tx.gasPrice = await rpc("eth_gasPrice", []);
+                tx.type = tx.type ?? "0x0";
+            }
+        }
+        return tx;
+    }
+    async function sendTransaction(params) {
+        const own = requireAccount();
+        const request = { ...(params[0] ?? {}) };
+        assertOwnAddress(request.from);
+        if (request.chainId !== undefined && Number(BigInt(request.chainId)) !== currentChainId) {
+            throw new SwivyProviderRpcError(4901, "Transaction chainId does not match the active chain");
+        }
+        delete request.from;
+        const filled = await fillTransaction(request, own.address);
+        const transaction = toSwivyTransactionPayload(filled);
+        const network = networkFor(currentChainId);
+        const challenge = await resolveChallengeId(options.getChallengeId, {
+            operation: "sendTransaction",
+            accountId: own.id,
+            address: getAddress(own.address),
+            chainId: currentChainId,
+            network,
+        });
+        const intent = await client.createTransactionIntentAndWait({
+            accountId: own.id,
+            chain: "evm",
+            ...challenge,
+            payload: {
+                ...(network ? { network } : {}),
+                ...(options.sponsorshipRequested ? { sponsorshipRequested: true } : {}),
+                transaction,
+            },
+        }, options.waitOptions);
+        const hash = intent.result?.transactionHash;
+        if (intent.status !== "completed" || !hash) {
+            throw new SwivyProviderRpcError(-32603, intent.result?.error ?? "swivy_transaction_failed", {
+                intentId: intent.id,
+            });
+        }
+        return hash;
+    }
+    function parseTypedData(raw) {
+        if (typeof raw === "string") {
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                throw new SwivyProviderRpcError(-32602, "Invalid typed data JSON");
+            }
+        }
+        if (raw && typeof raw === "object") {
+            return raw;
+        }
+        throw new SwivyProviderRpcError(-32602, "Missing typed data");
+    }
+    async function request({ method, params }) {
+        const args = paramsArray(params);
+        switch (method) {
+            case "eth_requestAccounts":
+            case "eth_accounts": {
+                if (!managedAccount) {
+                    if (method === "eth_requestAccounts") {
+                        throw new SwivyProviderRpcError(4100, "Swivy account is not connected");
+                    }
+                    return [];
+                }
+                const accounts = [getAddress(managedAccount.address)];
+                if (method === "eth_requestAccounts" && !connected) {
+                    connected = true;
+                    emit("connect", { chainId: numberToHex(currentChainId) });
+                }
+                return accounts;
+            }
+            case "eth_chainId":
+                return numberToHex(currentChainId);
+            case "net_version":
+                return String(currentChainId);
+            case "wallet_switchEthereumChain": {
+                const target = (args[0] ?? {});
+                if (!target.chainId) {
+                    throw new SwivyProviderRpcError(-32602, "Missing chainId");
+                }
+                const nextChainId = Number(BigInt(target.chainId));
+                if (!chains.has(nextChainId)) {
+                    throw new SwivyProviderRpcError(4902, `Unrecognized chain ID ${target.chainId}`);
+                }
+                if (nextChainId !== currentChainId) {
+                    currentChainId = nextChainId;
+                    emit("chainChanged", numberToHex(nextChainId));
+                }
+                return null;
+            }
+            case "wallet_requestPermissions":
+            case "wallet_getPermissions":
+                return managedAccount ? [{ parentCapability: "eth_accounts" }] : [];
+            case "wallet_revokePermissions":
+                return null;
+            case "personal_sign": {
+                const [data, address] = args;
+                assertOwnAddress(address);
+                if (typeof data !== "string") {
+                    throw new SwivyProviderRpcError(-32602, "Missing message");
+                }
+                return viemAccount.signMessage({
+                    message: isHex(data) ? { raw: data } : data,
+                });
+            }
+            case "eth_signTypedData_v4": {
+                const [address, typedData] = args;
+                assertOwnAddress(address);
+                return viemAccount.signTypedData(parseTypedData(typedData));
+            }
+            case "eth_signTransaction": {
+                const tx = { ...(args[0] ?? {}) };
+                assertOwnAddress(tx.from);
+                delete tx.from;
+                const filled = await fillTransaction(tx, requireAccount().address);
+                return viemAccount.signTransaction(toSwivyTransactionPayload(filled));
+            }
+            case "eth_sendTransaction":
+                return sendTransaction(args);
+            default:
+                if (UNSUPPORTED_SIGNING_METHODS.has(method)) {
+                    throw new SwivyProviderRpcError(4200, `Method not supported: ${method}`);
+                }
+                return rpc(method, args);
+        }
+    }
+    const provider = {
+        request,
+        on(event, listener) {
+            if (!listeners.has(event)) {
+                listeners.set(event, new Set());
+            }
+            listeners.get(event).add(listener);
+            return provider;
+        },
+        removeListener(event, listener) {
+            listeners.get(event)?.delete(listener);
+            return provider;
+        },
+        get account() {
+            return viemAccount;
+        },
+        get chainId() {
+            return currentChainId;
+        },
+        setAccount(next) {
+            managedAccount = next;
+            if (next) {
+                viemAccount = toSwivyViemAccount(client, next, options);
+            }
+            emit("accountsChanged", next ? [getAddress(next.address)] : []);
+        },
+        disconnect() {
+            managedAccount = null;
+            connected = false;
+            emit("accountsChanged", []);
+            emit("disconnect", new SwivyProviderRpcError(4900, "Swivy provider disconnected"));
+        },
+    };
+    return provider;
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@swivy/viem",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Swivy viem account and EIP-1193 provider (drop-in for Privy's toViemAccount and @privy-io/wagmi)",
+  "type": "module",
+  "main": "dist/packages/viem/src/index.js",
+  "types": "dist/packages/viem/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run test/*.test.ts"
+  },
+  "dependencies": {
+    "@swivy/core": "^1.0.0"
+  },
+  "peerDependencies": {
+    "viem": "^2.46.3"
+  },
+  "devDependencies": {
+    "ethers": "^6.17.0",
+    "viem": "^2.46.3"
+  },
+  "files": [
+    "dist/packages/viem/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/packages/viem/src/index.d.ts",
+      "import": "./dist/packages/viem/src/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Travisswop/Swivy.git",
+    "directory": "packages/viem"
+  }
+}