emblem-vault-ai-signers 0.1.0

package/README.md

@@ -0,0 +1,210 @@
+# Emblem Vault AI Signers
+
+Remote signer adapters for Emblem Vault that plug into popular Ethereum libraries:
+
+- `toViemAccount()` – creates a viem `Account` that signs via Emblem
+- `toEthersWallet()` – creates an ethers v6 `Signer` that signs via Emblem
+- `toWeb3Adapter()` – returns a minimal Web3-style signer adapter (EVM)
+- `toSolanaWeb3Signer()` – returns a stub Solana signer with `publicKey`
+- `toSolanaKitSigner()` – returns a stub Solana signer with `publicKey`
+
+> Note: The ethers adapter targets ethers v6.
+
+## Install
+
+```
+npm install emblem-vault-ai-signers
+# and bring your own peers
+npm install ethers viem
+```
+
+## Usage
+
+```ts
+import { createEmblemClient } from "emblem-vault-ai-signers";
+import { createPublicClient, http } from "viem";
+import { mainnet } from "viem/chains";
+import { JsonRpcProvider } from "ethers";
+
+const client = createEmblemClient({
+  apiKey: "your-x-api-key",
+  // baseUrl: "https://api.emblemvault.ai" // optional (tests use https://dev-api.emblemvault.ai)
+});
+
+// viem
+const account = await client.toViemAccount();
+const viemClient = createPublicClient({ chain: mainnet, transport: http() });
+// e.g. viemClient.signMessage({ account, message: "hello" })
+
+// ethers v6
+const provider = new JsonRpcProvider(process.env.RPC_URL!);
+const wallet = await client.toEthersWallet(provider);
+// e.g. await wallet.sendTransaction({ to: "0x...", value: 1n })
+
+// web3.js-like adapter (minimal)
+const web3Adapter = await client.toWeb3Adapter();
+await web3Adapter.signMessage("hello");
+
+// Solana stubs (address only; signing not yet implemented)
+const solWeb3 = await client.toSolanaWeb3Signer();
+console.log(solWeb3.publicKey);
+const solKit = await client.toSolanaKitSigner();
+console.log(solKit.publicKey);
+```
+
+## Replace Private Keys (Examples)
+
+Below are quick swaps showing how to remove local private keys and route signing through Emblem.
+
+### viem
+
+Old (local private key):
+```ts
+import { privateKeyToAccount } from "viem/accounts";
+import { createWalletClient, http } from "viem";
+import { sepolia } from "viem/chains";
+
+const account = privateKeyToAccount(process.env.PK as `0x${string}`);
+const wallet = createWalletClient({ chain: sepolia, transport: http(process.env.RPC_URL!), account });
+await wallet.sendTransaction({ to: "0x...", value: 1n });
+```
+
+New (Emblem remote signer):
+```ts
+import { createEmblemClient } from "emblem-vault-ai-signers";
+import { createWalletClient, http } from "viem";
+import { sepolia } from "viem/chains";
+
+const client = createEmblemClient({ apiKey: process.env.EMBLEM_API_KEY!, baseUrl: process.env.EMBLEM_BASE_URL });
+const account = await client.toViemAccount();
+const wallet = createWalletClient({ chain: sepolia, transport: http(process.env.RPC_URL!), account });
+
+// Message & typed data
+await wallet.signMessage({ account, message: "hello" });
+await wallet.signTypedData({
+  account,
+  domain: { name: "App", version: "1", chainId: 11155111 },
+  types: { Test: [{ name: "x", type: "uint256" }] },
+  primaryType: "Test",
+  message: { x: 42 },
+});
+
+// Transactions
+await wallet.sendTransaction({ account, to: "0x...", value: 1n });
+```
+
+### ethers v6
+
+Old (local private key):
+```ts
+import { Wallet, JsonRpcProvider } from "ethers";
+const provider = new JsonRpcProvider(process.env.RPC_URL!);
+const wallet = new Wallet(process.env.PK!, provider);
+await wallet.sendTransaction({ to: "0x...", value: 1n });
+```
+
+New (Emblem remote signer):
+```ts
+import { createEmblemClient } from "emblem-vault-ai-signers";
+import { JsonRpcProvider } from "ethers";
+
+const client = createEmblemClient({ apiKey: process.env.EMBLEM_API_KEY!, baseUrl: process.env.EMBLEM_BASE_URL });
+const provider = new JsonRpcProvider(process.env.RPC_URL!);
+const wallet = await client.toEthersWallet(provider);
+
+await wallet.signMessage("hello");
+await wallet.sendTransaction({ to: "0x...", value: 1n });
+```
+
+### web3.js (minimal adapter)
+
+Emblem includes a small adapter that returns signatures and raw transactions you can broadcast.
+
+```ts
+import { createEmblemClient } from "emblem-vault-ai-signers";
+import { JsonRpcProvider } from "ethers"; // for broadcasting raw tx
+
+const client = createEmblemClient({ apiKey: process.env.EMBLEM_API_KEY!, baseUrl: process.env.EMBLEM_BASE_URL });
+const adapter = await client.toWeb3Adapter();
+
+// Sign message / typed data
+const sig1 = await adapter.signMessage("hello");
+const sig2 = await adapter.signTypedData(
+  { name: "App", version: "1", chainId: 11155111 },
+  { Test: [{ name: "x", type: "uint256" }] },
+  { x: 42 }
+);
+
+// Sign transaction, then broadcast using ethers provider
+const { rawTransaction } = await adapter.signTransaction({
+  to: "0x...",
+  value: 1n,
+  chainId: 11155111,
+  gas: 21000n,
+  maxFeePerGas: 1n,
+  maxPriorityFeePerGas: 1n,
+});
+const provider = new JsonRpcProvider(process.env.RPC_URL!);
+await provider.broadcastTransaction(rawTransaction);
+```
+
+### Solana (stubs)
+
+These expose the Solana address derived from the vault. Signing is not implemented yet.
+
+```ts
+const solWeb3 = await client.toSolanaWeb3Signer();
+console.log(solWeb3.publicKey);
+```
+
+## API
+
+```ts
+type EmblemRemoteConfig = {
+  apiKey: string;
+  baseUrl?: string; // default https://api.emblemvault.ai
+};
+
+createEmblemClient(config): EmblemVaultClient
+EmblemVaultClient#toViemAccount(): Promise<Account>
+EmblemVaultClient#toEthersWallet(provider?): Promise<Signer>
+EmblemVaultClient#toWeb3Adapter(): Promise<{ address, signMessage, signTypedData, signTransaction }>
+EmblemVaultClient#toSolanaWeb3Signer(): Promise<{ publicKey }>
+EmblemVaultClient#toSolanaKitSigner(): Promise<{ publicKey }>
+```
+
+Adapters POST to the Emblem API endpoints:
+
+- `POST /sign-eth-message` – `{ vaultId, message }`
+- `POST /sign-typed-message` – `{ vaultId, domain, types, message }`
+- `POST /sign-eth-tx` – `{ vaultId, transaction }` (expects ethers-serializable fields)
+
+On first use, both adapters query `GET /vault/info` with header `x-api-key` to obtain:
+
+- Vault ID
+- Solana Address
+- EVM Address
+
+Transactions are normalized to hex/number-like fields before submission.
+
+## Testing
+
+- Copy `.env.example` to `.env` and set:
+  - `EMBLEM_API_KEY` – your dev API key
+  - `EMBLEM_BASE_URL` – usually `https://dev-api.emblemvault.ai`
+- Run `npm test`
+
+Notes:
+- Tests mock `fetch` and do not hit the network.
+- Node 18+ (or a fetch polyfill) is required at runtime.
+
+### Integration tests
+
+Integration tests hit the real API using your `.env` values and verify signatures with viem/ethers.
+
+- Ensure `.env` contains working credentials (typically dev base URL)
+- Run: `npm run test:integration`
+
+These tests:
+- Sign and verify messages and typed data
+- Sign transactions and verify the recovered `from` address

package/dist/ethers.d.ts

@@ -0,0 +1,15 @@
+import type { EmblemRemoteConfig, VaultInfo } from "./types";
+import { AbstractSigner } from "ethers";
+import type { Provider, TransactionRequest, TransactionResponse, TypedDataDomain, TypedDataField } from "ethers";
+export declare class EmblemEthersWallet extends AbstractSigner {
+    #private;
+    readonly address: `0x${string}`;
+    constructor(address: `0x${string}`, vaultId: string, config: EmblemRemoteConfig, provider?: Provider | null);
+    getAddress(): Promise<string>;
+    connect(provider: Provider): EmblemEthersWallet;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+    signTransaction(tx: TransactionRequest): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+}
+export declare function toEthersWallet(config: EmblemRemoteConfig, provider?: Provider | null, infoOverride?: VaultInfo): Promise<EmblemEthersWallet>;

package/dist/ethers.js

@@ -0,0 +1,71 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EmblemEthersWallet_config, _EmblemEthersWallet_vaultId;
+import { emblemPost } from "./http";
+import { bytesToHex, normalizeTxForEmblem } from "./utils";
+import { fetchVaultInfo } from "./vault";
+import { AbstractSigner, } from "ethers";
+export class EmblemEthersWallet extends AbstractSigner {
+    constructor(address, vaultId, config, provider) {
+        super(provider ?? null);
+        _EmblemEthersWallet_config.set(this, void 0);
+        _EmblemEthersWallet_vaultId.set(this, void 0);
+        this.address = address;
+        __classPrivateFieldSet(this, _EmblemEthersWallet_vaultId, vaultId, "f");
+        __classPrivateFieldSet(this, _EmblemEthersWallet_config, config, "f");
+    }
+    async getAddress() {
+        return this.address;
+    }
+    connect(provider) {
+        return new EmblemEthersWallet(this.address, __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f"), __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"), provider);
+    }
+    async signMessage(message) {
+        const vaultId = __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f");
+        const payload = typeof message === "string" ? message : bytesToHex(message);
+        const data = await emblemPost("/sign-eth-message", { vaultId, message: payload }, __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"));
+        return data.signature;
+    }
+    async signTypedData(domain, types, value) {
+        const vaultId = __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f");
+        const data = await emblemPost("/sign-typed-message", { vaultId, domain, types, message: value }, __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"));
+        return data.signature;
+    }
+    async signTransaction(tx) {
+        // Ensure `from` (if present) matches this signer
+        const from = tx.from;
+        if (from && from.toLowerCase() !== this.address.toLowerCase()) {
+            throw new Error("transaction from does not match signer address");
+        }
+        // Let provider fill fields if available
+        const toSign = this.provider ? await this.populateTransaction(tx) : { ...tx };
+        // Ethers serializers do not include `from`
+        delete toSign.from;
+        const normalized = normalizeTxForEmblem(toSign);
+        const vaultId = __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f");
+        const resp = await emblemPost("/sign-eth-tx", { vaultId, transaction: normalized }, __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"));
+        return resp.signedTransaction;
+    }
+    async sendTransaction(tx) {
+        if (!this.provider) {
+            throw new Error("EmblemEthersWallet requires a provider to send transactions");
+        }
+        const populated = await this.populateTransaction(tx);
+        const signed = await this.signTransaction(populated);
+        return await this.provider.broadcastTransaction(signed);
+    }
+}
+_EmblemEthersWallet_config = new WeakMap(), _EmblemEthersWallet_vaultId = new WeakMap();
+export async function toEthersWallet(config, provider, infoOverride) {
+    const info = infoOverride ?? await fetchVaultInfo(config);
+    return new EmblemEthersWallet(info.evmAddress, info.vaultId, config, provider ?? null);
+}

package/dist/http.d.ts

@@ -0,0 +1,3 @@
+import type { EmblemRemoteConfig } from "./types";
+export declare function emblemPost<T = any>(path: string, body: any, { apiKey, baseUrl }: EmblemRemoteConfig): Promise<T>;
+export declare function emblemGet<T = any>(path: string, { apiKey, baseUrl }: EmblemRemoteConfig): Promise<T>;

package/dist/http.js

@@ -0,0 +1,28 @@
+export async function emblemPost(path, body, { apiKey, baseUrl = "https://api.emblemvault.ai" }) {
+    const res = await fetch(`${baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Emblem signer error ${res.status}: ${text || res.statusText}`);
+    }
+    return res.json();
+}
+export async function emblemGet(path, { apiKey, baseUrl = "https://api.emblemvault.ai" }) {
+    const res = await fetch(`${baseUrl}${path}`, {
+        method: "GET",
+        headers: {
+            "x-api-key": apiKey,
+        },
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Emblem signer error ${res.status}: ${text || res.statusText}`);
+    }
+    return res.json();
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import type { Provider } from "ethers";
+import type { EmblemRemoteConfig } from "./types";
+export type { EmblemRemoteConfig, Hex, VaultInfo } from "./types";
+import { EmblemEthersWallet } from "./ethers";
+import { EmblemSolanaSigner } from "./solana";
+import { EmblemWeb3Adapter } from "./web3";
+export declare class EmblemVaultClient {
+    private readonly config;
+    private _infoPromise?;
+    constructor(config: EmblemRemoteConfig);
+    /** Lazily fetch and cache vault info */
+    private getInfo;
+    toViemAccount(): Promise<{
+        address: import("abitype").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign?: ((parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>) | undefined | undefined;
+        signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").Hex>;
+        signTypedData: <const typedData extends import("abitype").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: string;
+        type: "local";
+    }>;
+    toEthersWallet(provider?: Provider | null): Promise<EmblemEthersWallet>;
+    toSolanaWeb3Signer(): Promise<EmblemSolanaSigner>;
+    toSolanaKitSigner(): Promise<EmblemSolanaSigner>;
+    toWeb3Adapter(): Promise<EmblemWeb3Adapter>;
+}
+export declare function createEmblemClient(config: EmblemRemoteConfig): EmblemVaultClient;

package/dist/index.js

@@ -0,0 +1,39 @@
+import { toViemAccount } from "./viem";
+import { toEthersWallet } from "./ethers";
+import { toSolanaKitSigner, toSolanaWeb3Signer } from "./solana";
+import { toWeb3Adapter } from "./web3";
+import { fetchVaultInfo } from "./vault";
+export class EmblemVaultClient {
+    constructor(config) {
+        this.config = config;
+    }
+    /** Lazily fetch and cache vault info */
+    getInfo() {
+        if (!this._infoPromise)
+            this._infoPromise = fetchVaultInfo(this.config);
+        return this._infoPromise;
+    }
+    async toViemAccount() {
+        const info = await this.getInfo();
+        return toViemAccount(this.config, info);
+    }
+    async toEthersWallet(provider) {
+        const info = await this.getInfo();
+        return toEthersWallet(this.config, provider ?? null, info);
+    }
+    async toSolanaWeb3Signer() {
+        const info = await this.getInfo();
+        return toSolanaWeb3Signer(this.config, info);
+    }
+    async toSolanaKitSigner() {
+        const info = await this.getInfo();
+        return toSolanaKitSigner(this.config, info);
+    }
+    async toWeb3Adapter() {
+        const info = await this.getInfo();
+        return toWeb3Adapter(this.config, info);
+    }
+}
+export function createEmblemClient(config) {
+    return new EmblemVaultClient(config);
+}

package/dist/solana.d.ts

@@ -0,0 +1,9 @@
+import type { EmblemRemoteConfig, VaultInfo } from "./types";
+export declare class EmblemSolanaSigner {
+    readonly publicKey: string;
+    constructor(publicKey: string);
+    signMessage(_message: Uint8Array | string): Promise<string>;
+    signTransaction(_tx: unknown): Promise<string>;
+}
+export declare function toSolanaWeb3Signer(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<EmblemSolanaSigner>;
+export declare function toSolanaKitSigner(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<EmblemSolanaSigner>;

package/dist/solana.js

@@ -0,0 +1,20 @@
+import { fetchVaultInfo } from "./vault";
+export class EmblemSolanaSigner {
+    constructor(publicKey) {
+        this.publicKey = publicKey;
+    }
+    async signMessage(_message) {
+        throw new Error("Solana signing via Emblem is not implemented yet");
+    }
+    async signTransaction(_tx) {
+        throw new Error("Solana transaction signing via Emblem is not implemented yet");
+    }
+}
+export async function toSolanaWeb3Signer(config, infoOverride) {
+    const info = infoOverride ?? (await fetchVaultInfo(config));
+    return new EmblemSolanaSigner(info.address);
+}
+export async function toSolanaKitSigner(config, infoOverride) {
+    const info = infoOverride ?? (await fetchVaultInfo(config));
+    return new EmblemSolanaSigner(info.address);
+}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+export type Hex = `0x${string}`;
+/** Config for Emblem remote signer */
+export type EmblemRemoteConfig = {
+    /** x-api-key for your authenticate middleware */
+    apiKey: string;
+    /** Base URL for the Emblem signer API */
+    baseUrl?: string;
+};
+export type VaultInfo = {
+    vaultId: string;
+    address: string;
+    evmAddress: `0x${string}`;
+    created_by?: string;
+};

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Hex } from "./types";
+export declare function toHexIfBigInt(v: any): any;
+/**
+ * viem txs sometimes have bigint / hex / optional fields. Ethers serializers
+ * accept hex strings for numeric fields. Normalize where helpful.
+ */
+export declare function normalizeTxForEmblem(tx: any): any;
+export declare function isHexString(value: any): value is Hex;
+export declare function bytesToHex(bytes: ArrayLike<number>): Hex;

package/dist/utils.js

@@ -0,0 +1,50 @@
+export function toHexIfBigInt(v) {
+    return typeof v === "bigint" ? ("0x" + v.toString(16)) : v;
+}
+/**
+ * viem txs sometimes have bigint / hex / optional fields. Ethers serializers
+ * accept hex strings for numeric fields. Normalize where helpful.
+ */
+export function normalizeTxForEmblem(tx) {
+    const out = { ...tx };
+    if (out.value !== undefined)
+        out.value = toHexIfBigInt(out.value);
+    if (out.gas !== undefined) {
+        out.gasLimit = toHexIfBigInt(out.gas);
+        delete out.gas;
+    }
+    if (out.gasLimit !== undefined)
+        out.gasLimit = toHexIfBigInt(out.gasLimit);
+    if (out.gasPrice !== undefined)
+        out.gasPrice = toHexIfBigInt(out.gasPrice);
+    if (out.maxFeePerGas !== undefined)
+        out.maxFeePerGas = toHexIfBigInt(out.maxFeePerGas);
+    if (out.maxPriorityFeePerGas !== undefined)
+        out.maxPriorityFeePerGas = toHexIfBigInt(out.maxPriorityFeePerGas);
+    if (out.nonce !== undefined)
+        out.nonce = Number(out.nonce);
+    if (out.chainId !== undefined)
+        out.chainId = Number(out.chainId);
+    // Some backends only accept legacy fields; fold EIP-1559 into gasPrice and drop unsupported keys
+    if (out.maxFeePerGas !== undefined || out.maxPriorityFeePerGas !== undefined) {
+        if (out.gasPrice === undefined && out.maxFeePerGas !== undefined) {
+            out.gasPrice = out.maxFeePerGas;
+        }
+        delete out.maxFeePerGas;
+        delete out.maxPriorityFeePerGas;
+    }
+    // Remove fields commonly unsupported by legacy serializers
+    delete out.type;
+    delete out.accessList;
+    return out;
+}
+export function isHexString(value) {
+    return typeof value === "string" && /^0x[0-9a-fA-F]*$/.test(value);
+}
+export function bytesToHex(bytes) {
+    let out = "0x";
+    for (let i = 0; i < bytes.length; i++) {
+        out += bytes[i].toString(16).padStart(2, "0");
+    }
+    return out;
+}

package/dist/vault.d.ts

@@ -0,0 +1,2 @@
+import type { EmblemRemoteConfig, VaultInfo } from "./types";
+export declare function fetchVaultInfo(config: EmblemRemoteConfig): Promise<VaultInfo>;

package/dist/vault.js

@@ -0,0 +1,17 @@
+import { emblemGet, emblemPost } from "./http";
+export async function fetchVaultInfo(config) {
+    let data;
+    try {
+        data = await emblemGet("/vault/info", config);
+    }
+    catch (err) {
+        // Some environments may require POST for this endpoint; try POST fallback
+        data = await emblemPost("/vault/info", {}, config);
+    }
+    return {
+        vaultId: data.vaultId,
+        address: data.address,
+        evmAddress: data.evmAddress,
+        created_by: data.created_by,
+    };
+}

package/dist/viem.d.ts

@@ -0,0 +1,20 @@
+import type { EmblemRemoteConfig, VaultInfo } from "./types";
+import type { TypedDataDefinition } from "viem";
+export declare function toViemAccount(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<{
+    address: import("abitype").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign?: ((parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>) | undefined | undefined;
+    signAuthorization?: ((parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>) | undefined | undefined;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<import("viem").Hex>;
+    signTypedData: <const typedData extends import("abitype").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    publicKey: import("viem").Hex;
+    source: string;
+    type: "local";
+}>;

package/dist/viem.js

@@ -0,0 +1,42 @@
+import { emblemPost } from "./http";
+import { bytesToHex, isHexString, normalizeTxForEmblem } from "./utils";
+import { toAccount } from "viem/accounts";
+import { fetchVaultInfo } from "./vault";
+export async function toViemAccount(config, infoOverride) {
+    const info = infoOverride ?? await fetchVaultInfo(config);
+    const { evmAddress, vaultId } = info;
+    return toAccount({
+        address: evmAddress,
+        async signMessage({ message }) {
+            let payload;
+            if (typeof message === "string") {
+                payload = message;
+            }
+            else if (message && typeof message.raw !== "undefined") {
+                const raw = message.raw;
+                payload = typeof raw === "string" ? raw : bytesToHex(raw);
+            }
+            else if (message instanceof Uint8Array) {
+                payload = bytesToHex(message);
+            }
+            else if (isHexString(message)) {
+                payload = message;
+            }
+            else {
+                payload = String(message);
+            }
+            const data = await emblemPost("/sign-eth-message", { vaultId, message: payload }, config);
+            return data.signature;
+        },
+        async signTypedData(typedData) {
+            const { domain, types, message } = typedData;
+            const data = await emblemPost("/sign-typed-message", { vaultId, domain, types, message }, config);
+            return data.signature;
+        },
+        async signTransaction(tx, _opts) {
+            const normalizedTx = normalizeTxForEmblem(tx);
+            const data = await emblemPost("/sign-eth-tx", { vaultId, transaction: normalizedTx }, config);
+            return data.signedTransaction;
+        },
+    });
+}

package/dist/web3.d.ts

@@ -0,0 +1,12 @@
+import type { EmblemRemoteConfig, Hex, VaultInfo } from "./types";
+export declare class EmblemWeb3Adapter {
+    #private;
+    readonly address: `0x${string}`;
+    constructor(address: `0x${string}`, vaultId: string, config: EmblemRemoteConfig);
+    signMessage(message: string | Uint8Array): Promise<Hex>;
+    signTypedData(domain: any, types: any, message: any): Promise<Hex>;
+    signTransaction(tx: any): Promise<{
+        rawTransaction: Hex;
+    }>;
+}
+export declare function toWeb3Adapter(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<EmblemWeb3Adapter>;

package/dist/web3.js

@@ -0,0 +1,43 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EmblemWeb3Adapter_vaultId, _EmblemWeb3Adapter_config;
+import { emblemPost } from "./http";
+import { bytesToHex, normalizeTxForEmblem } from "./utils";
+import { fetchVaultInfo } from "./vault";
+export class EmblemWeb3Adapter {
+    constructor(address, vaultId, config) {
+        _EmblemWeb3Adapter_vaultId.set(this, void 0);
+        _EmblemWeb3Adapter_config.set(this, void 0);
+        this.address = address;
+        __classPrivateFieldSet(this, _EmblemWeb3Adapter_vaultId, vaultId, "f");
+        __classPrivateFieldSet(this, _EmblemWeb3Adapter_config, config, "f");
+    }
+    async signMessage(message) {
+        const payload = typeof message === "string" ? message : bytesToHex(message);
+        const data = await emblemPost("/sign-eth-message", { vaultId: __classPrivateFieldGet(this, _EmblemWeb3Adapter_vaultId, "f"), message: payload }, __classPrivateFieldGet(this, _EmblemWeb3Adapter_config, "f"));
+        return data.signature;
+    }
+    async signTypedData(domain, types, message) {
+        const data = await emblemPost("/sign-typed-message", { vaultId: __classPrivateFieldGet(this, _EmblemWeb3Adapter_vaultId, "f"), domain, types, message }, __classPrivateFieldGet(this, _EmblemWeb3Adapter_config, "f"));
+        return data.signature;
+    }
+    async signTransaction(tx) {
+        const normalized = normalizeTxForEmblem(tx);
+        const resp = await emblemPost("/sign-eth-tx", { vaultId: __classPrivateFieldGet(this, _EmblemWeb3Adapter_vaultId, "f"), transaction: normalized }, __classPrivateFieldGet(this, _EmblemWeb3Adapter_config, "f"));
+        return { rawTransaction: resp.signedTransaction };
+    }
+}
+_EmblemWeb3Adapter_vaultId = new WeakMap(), _EmblemWeb3Adapter_config = new WeakMap();
+export async function toWeb3Adapter(config, infoOverride) {
+    const info = infoOverride ?? (await fetchVaultInfo(config));
+    return new EmblemWeb3Adapter(info.evmAddress, info.vaultId, config);
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "emblem-vault-ai-signers",
+  "version": "0.1.0",
+  "description": "Emblem Vault remote signer adapters for viem and ethers",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run --reporter=verbose",
+    "test:watch": "vitest --reporter=verbose",
+    "test:ci": "vitest run --reporter=default",
+    "test:integration": "vitest -c vitest.int.config.ts run --reporter=verbose"
+  },
+  "keywords": [
+    "emblem",
+    "vault",
+    "signer",
+    "ethers",
+    "viem"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "ethers": "^6.10.0",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0",
+    "dotenv": "^16.4.5",
+    "ethers": "^6.10.0",
+    "viem": "^2.0.0"
+  }
+}