emblem-vault-ai-signers 0.1.1 → 0.1.2

package/README.md

@@ -4,6 +4,8 @@ Remote signer adapters for Emblem Vault that plug into popular Ethereum librarie
 
 - `toViemAccount()` – creates a viem `Account` that signs via Emblem
 - `toEthersWallet()` – creates an ethers v6 `Signer` that signs via Emblem
+  - Implements `initialize()`, `getVaultId()`, `setChainId()`, `getChainId()`
+  - Adds `signAndBroadcast(tx, waitForReceipt?)` helper (optional)
 - `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`
@@ -39,7 +41,17 @@ const viemClient = createPublicClient({ chain: mainnet, transport: http() });
 // 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 })
+
+// Read metadata
+const addr = await wallet.getAddress();
+const vaultId = wallet.getVaultId();
+
+// Sign & send via ethers Provider
+await wallet.signMessage("hello");
+await wallet.sendTransaction({ to: "0x...", value: 1n });
+
+// Or sign and broadcast, returning tx hash
+const txHash = await wallet.signAndBroadcast({ to: "0x...", value: 1n }, true);
 
 // web3.js-like adapter (minimal)
 const web3Adapter = await client.toWeb3Adapter();
@@ -171,6 +183,13 @@ EmblemVaultClient#toEthersWallet(provider?): Promise<Signer>
 EmblemVaultClient#toWeb3Adapter(): Promise<{ address, signMessage, signTypedData, signTransaction }>
 EmblemVaultClient#toSolanaWeb3Signer(): Promise<{ publicKey }>
 EmblemVaultClient#toSolanaKitSigner(): Promise<{ publicKey }>
+
+Ethers wallet (v6) adds:
+- initialize(): Promise<void>
+- getVaultId(): string
+- setChainId(n: number): void
+- getChainId(): number
+- signAndBroadcast(tx: TransactionRequest, waitForReceipt?: boolean): Promise<string>
 ```
 
 Adapters POST to the Emblem API endpoints:

package/dist/ethers.d.ts

@@ -1,15 +1,28 @@
 import type { EmblemRemoteConfig, VaultInfo } from "./types";
 import { AbstractSigner } from "ethers";
-import type { Provider, TransactionRequest, TransactionResponse, TypedDataDomain, TypedDataField } from "ethers";
+import type { Provider, TransactionLike, 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);
+    private readonly _config;
+    private _address;
+    private _vaultId;
+    private _chainId;
+    constructor(config: EmblemRemoteConfig, provider?: Provider | null, seed?: {
+        address?: `0x${string}`;
+        vaultId?: string;
+        chainId?: number;
+    });
+    initialize(): Promise<void>;
     getAddress(): Promise<string>;
+    getVaultId(): string;
+    setChainId(chainId: number): void;
+    getChainId(): number;
     connect(provider: Provider): EmblemEthersWallet;
     signMessage(message: string | Uint8Array): Promise<string>;
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): 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>;
+    populateTransaction(transaction: TransactionRequest): Promise<TransactionLike<string>>;
+    signAndBroadcast(transaction: TransactionRequest, waitForReceipt?: boolean): Promise<string>;
 }
 export declare function toEthersWallet(config: EmblemRemoteConfig, provider?: Provider | null, infoOverride?: VaultInfo): Promise<EmblemEthersWallet>;

package/dist/ethers.js

@@ -1,71 +1,163 @@
-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";
+import { AbstractSigner, resolveAddress } from "ethers";
 export class EmblemEthersWallet extends AbstractSigner {
-    constructor(address, vaultId, config, provider) {
+    constructor(config, provider, seed) {
         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");
+        this._address = null;
+        this._vaultId = null;
+        this._chainId = 1;
+        this._config = config;
+        if (seed?.address)
+            this._address = seed.address;
+        if (seed?.vaultId)
+            this._vaultId = seed.vaultId;
+        if (seed?.chainId)
+            this._chainId = seed.chainId;
+    }
+    async initialize() {
+        const info = await fetchVaultInfo(this._config);
+        this._address = info.evmAddress;
+        this._vaultId = info.vaultId;
     }
     async getAddress() {
-        return this.address;
+        if (!this._address)
+            await this.initialize();
+        return this._address;
+    }
+    getVaultId() {
+        if (!this._vaultId)
+            throw new Error("Wallet not initialized. Call initialize() first.");
+        return this._vaultId;
+    }
+    setChainId(chainId) {
+        this._chainId = chainId;
+    }
+    getChainId() {
+        return this._chainId;
     }
     connect(provider) {
-        return new EmblemEthersWallet(this.address, __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f"), __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"), provider);
+        if (!provider)
+            throw new Error("Provider cannot be null");
+        return new EmblemEthersWallet(this._config, provider, { address: this._address ?? undefined, vaultId: this._vaultId ?? undefined, chainId: this._chainId });
     }
     async signMessage(message) {
-        const vaultId = __classPrivateFieldGet(this, _EmblemEthersWallet_vaultId, "f");
+        if (!this._vaultId)
+            await this.initialize();
         const payload = typeof message === "string" ? message : bytesToHex(message);
-        const data = await emblemPost("/sign-eth-message", { vaultId, message: payload }, __classPrivateFieldGet(this, _EmblemEthersWallet_config, "f"));
+        const data = await emblemPost("/sign-eth-message", { vaultId: this._vaultId, message: payload }, this._config);
         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"));
+        if (!this._vaultId)
+            await this.initialize();
+        const cleanTypes = { ...types };
+        if (cleanTypes && cleanTypes.EIP712Domain) {
+            delete cleanTypes.EIP712Domain;
+        }
+        const data = await emblemPost("/sign-typed-message", { vaultId: this._vaultId, domain, types: cleanTypes, message: value }, this._config);
         return data.signature;
     }
+    async _signTypedData(domain, types, value) {
+        return this.signTypedData(domain, types, value);
+    }
     async signTransaction(tx) {
-        // Ensure `from` (if present) matches this signer
+        if (!this._vaultId)
+            await this.initialize();
         const from = tx.from;
-        if (from && from.toLowerCase() !== this.address.toLowerCase()) {
+        const addr = await this.getAddress();
+        if (from && from.toLowerCase() !== addr.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;
+        if (toSign.from)
+            delete toSign.from;
+        if (!('to' in toSign) || !toSign.to) {
+            throw new Error("Transaction must have a 'to' address");
+        }
+        if (toSign.nonce === undefined || toSign.nonce === null) {
+            throw new Error("Transaction must have a nonce");
+        }
         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"));
+        const resp = await emblemPost("/sign-eth-tx", { vaultId: this._vaultId, transaction: normalized, options: { chainId: this._chainId } }, this._config);
         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);
+        if (!this.provider)
+            throw new Error("Provider required to send transaction");
+        const signed = await this.signTransaction(tx);
         return await this.provider.broadcastTransaction(signed);
     }
+    async populateTransaction(transaction) {
+        const tx = { ...transaction };
+        if (!this.provider)
+            throw new Error("Provider required to populate transaction");
+        const fromAddress = tx.from ? await resolveAddress(tx.from, this.provider) : await this.getAddress();
+        let chainId;
+        if (!tx.chainId) {
+            const network = await this.provider.getNetwork();
+            chainId = network.chainId;
+            this._chainId = Number(network.chainId);
+        }
+        else {
+            chainId = BigInt(tx.chainId);
+            this._chainId = Number(tx.chainId);
+        }
+        const nonce = tx.nonce != null ? Number(tx.nonce) : await this.provider.getTransactionCount(fromAddress, "pending");
+        const toAddress = tx.to ? await resolveAddress(tx.to, this.provider) : null;
+        const value = tx.value ? BigInt(tx.value.toString()) : 0n;
+        let gasLimit;
+        if (!tx.gasLimit) {
+            try {
+                gasLimit = await this.provider.estimateGas({ ...tx, from: fromAddress });
+            }
+            catch {
+                gasLimit = 21000n;
+            }
+        }
+        else {
+            gasLimit = BigInt(tx.gasLimit.toString());
+        }
+        let gasPrice = null;
+        if (!tx.gasPrice && tx.type !== 2) {
+            const feeData = await this.provider.getFeeData();
+            gasPrice = feeData.gasPrice ?? null;
+        }
+        else if (tx.gasPrice) {
+            gasPrice = BigInt(tx.gasPrice.toString());
+        }
+        const populated = {
+            from: fromAddress,
+            to: toAddress,
+            value,
+            nonce,
+            gasLimit,
+            data: tx.data,
+            chainId,
+            type: tx.type || undefined,
+        };
+        if (gasPrice !== null)
+            populated.gasPrice = gasPrice;
+        if (tx.maxFeePerGas)
+            populated.maxFeePerGas = BigInt(tx.maxFeePerGas.toString());
+        if (tx.maxPriorityFeePerGas)
+            populated.maxPriorityFeePerGas = BigInt(tx.maxPriorityFeePerGas.toString());
+        return populated;
+    }
+    async signAndBroadcast(transaction, waitForReceipt = false) {
+        if (!this.provider)
+            throw new Error("Provider required to send transaction");
+        const signed = await this.signTransaction(transaction);
+        const resp = await this.provider.broadcastTransaction(signed);
+        const hash = resp.hash;
+        if (waitForReceipt) {
+            await this.provider.waitForTransaction(hash);
+        }
+        return hash;
+    }
 }
-_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);
+    const info = infoOverride ?? (await fetchVaultInfo(config));
+    return new EmblemEthersWallet(config, provider ?? null, { address: info.evmAddress, vaultId: info.vaultId });
 }

package/dist/types.d.ts

@@ -8,6 +8,7 @@ export type EmblemRemoteConfig = {
 };
 export type VaultInfo = {
     vaultId: string;
+    tokenId?: string;
     address: string;
     evmAddress: `0x${string}`;
     created_by?: string;

package/dist/vault.js

@@ -10,6 +10,7 @@ export async function fetchVaultInfo(config) {
     }
     return {
         vaultId: data.vaultId,
+        tokenId: data.vaultId,
         address: data.address,
         evmAddress: data.evmAddress,
         created_by: data.created_by,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-ai-signers",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Emblem Vault remote signer adapters for viem and ethers",
   "type": "module",
   "main": "dist/index.js",