@verbeth/sdk 0.1.4

package/dist/src/client/VerbethClient.js

@@ -0,0 +1,191 @@
+// packages/sdk/src/client/VerbethClient.ts
+import nacl from 'tweetnacl';
+import { initiateHandshake, respondToHandshake, sendEncryptedMessage } from '../send.js';
+import { deriveDuplexTopics } from '../crypto.js';
+import * as crypto from '../crypto.js';
+import * as payload from '../payload.js';
+import * as verify from '../verify.js';
+import * as utils from '../utils.js';
+import * as identity from '../identity.js';
+/**
+ * High-level client for Verbeth E2EE messaging
+ *
+ * VerbethClient provides a simplified API for common operations while
+ * maintaining access to all low-level functions.
+ *
+ * @example
+ * ```typescript
+ * const client = new VerbethClient({
+ *   executor,
+ *   identityKeyPair,
+ *   identityProof,
+ *   signer,
+ *   address: '0x...'
+ * });
+ *
+ * // Send a handshake
+ * const { tx, ephemeralKeyPair } = await client.sendHandshake(
+ *   '0xBob...',
+ *   'Hello Bob!'
+ * );
+ *
+ * // Send a message
+ * await client.sendMessage(
+ *   contact.topicOutbound,
+ *   contact.identityPubKey,
+ *   'Hello again!'
+ * );
+ * ```
+ */
+export class VerbethClient {
+    /**
+     * creates a new VerbethClient instance
+     *
+     * @param config - Client configuration with session-level parameters
+     */
+    constructor(config) {
+        this.executor = config.executor;
+        this.identityKeyPair = config.identityKeyPair;
+        this.identityProof = config.identityProof;
+        this.signer = config.signer;
+        this.address = config.address;
+    }
+    /**
+     * Initiates a handshake with a recipient
+     *
+     * generates an ephemeral keypair for this handshake.
+     * the ephemeralKeyPair must be stored to decrypt the response later.
+     *
+     * @param recipientAddress - Blockchain address of the recipient
+     * @param message - Plaintext message to include in the handshake
+     * @returns Transaction response and the ephemeral keypair (must be stored!)
+     *
+     * @example
+     * ```typescript
+     * const { tx, ephemeralKeyPair } = await client.sendHandshake(
+     *   '0xBob...',
+     *   'Hi Bob!'
+     * );
+     *
+     * // Store ephemeralKeyPair.secretKey to decrypt Bob's response
+     * await storage.saveContact({
+     *   address: '0xBob...',
+     *   ephemeralKey: ephemeralKeyPair.secretKey,
+     *   // ...
+     * });
+     * ```
+     */
+    async sendHandshake(recipientAddress, message) {
+        const ephemeralKeyPair = nacl.box.keyPair();
+        const tx = await initiateHandshake({
+            executor: this.executor,
+            recipientAddress,
+            identityKeyPair: this.identityKeyPair,
+            ephemeralPubKey: ephemeralKeyPair.publicKey,
+            plaintextPayload: message,
+            identityProof: this.identityProof,
+            signer: this.signer,
+        });
+        return { tx, ephemeralKeyPair };
+    }
+    /**
+     * Accepts a handshake from an initiator
+     *
+     * derives duplex topics for the conversation and returns them.
+     *
+     * @param initiatorEphemeralPubKey - initiator's ephemeral public key from handshake event
+     * @param initiatorIdentityPubKey - initiator's long-term X25519 identity key
+     * @param note - response message to send back
+     * @returns transaction, derived duplex topics, and response tag
+     *
+     * @example
+     * ```typescript
+     * const { tx, duplexTopics } = await client.acceptHandshake(
+     *   handshake.ephemeralPubKey,
+     *   handshake.identityPubKey,
+     *   'Hello Alice!'
+     * );
+     *
+     * // Store the topics for future messaging
+     * await storage.saveContact({
+     *   address: handshake.sender,
+     *   topicOutbound: duplexTopics.topicIn,  // Responder writes to topicIn
+     *   topicInbound: duplexTopics.topicOut,  // Responder reads from topicOut
+     *   // ...
+     * });
+     * ```
+     */
+    async acceptHandshake(initiatorEphemeralPubKey, initiatorIdentityPubKey, note) {
+        const { tx, salt, tag } = await respondToHandshake({
+            executor: this.executor,
+            initiatorPubKey: initiatorEphemeralPubKey,
+            responderIdentityKeyPair: this.identityKeyPair,
+            note,
+            identityProof: this.identityProof,
+            signer: this.signer,
+            initiatorIdentityPubKey,
+        });
+        const duplexTopics = deriveDuplexTopics(this.identityKeyPair.secretKey, initiatorIdentityPubKey, salt);
+        return { tx, duplexTopics, tag };
+    }
+    /**
+     * Sends an encrypted message to a contact
+     *
+     * handles timestamp, signing keys, and sender address.
+     *
+     * @param topicOutbound - The outbound topic for this conversation
+     * @param recipientPubKey - Recipient's X25519 public key (from handshake)
+     * @param message - Plaintext message to encrypt and send
+     * @returns Transaction response
+     *
+     * @example
+     * ```typescript
+     * await client.sendMessage(
+     *   contact.topicOutbound,
+     *   contact.identityPubKey,
+     *   'Hello again!'
+     * );
+     * ```
+     */
+    async sendMessage(topicOutbound, recipientPubKey, message) {
+        const signingKeyPair = {
+            publicKey: this.identityKeyPair.signingPublicKey,
+            secretKey: this.identityKeyPair.signingSecretKey,
+        };
+        const timestamp = Math.floor(Date.now() / 1000);
+        return sendEncryptedMessage({
+            executor: this.executor,
+            topic: topicOutbound,
+            message,
+            recipientPubKey,
+            senderAddress: this.address,
+            senderSignKeyPair: signingKeyPair,
+            timestamp,
+        });
+    }
+    // ========== low-level API ==========
+    get crypto() {
+        return crypto;
+    }
+    get payload() {
+        return payload;
+    }
+    get verify() {
+        return verify;
+    }
+    get utils() {
+        return utils;
+    }
+    get identity() {
+        return identity;
+    }
+    get executorInstance() {
+        return this.executor;
+    }
+    get identityKeyPairInstance() {
+        return this.identityKeyPair;
+    }
+    get userAddress() {
+        return this.address;
+    }
+}

package/dist/src/client/index.d.ts

@@ -0,0 +1,3 @@
+export { VerbethClient } from './VerbethClient.js';
+export type { VerbethClientConfig, HandshakeResult, HandshakeResponseResult } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACxB,MAAM,YAAY,CAAC"}

package/dist/src/client/index.js

@@ -0,0 +1,2 @@
+// packages/sdk/src/client/index.ts
+export { VerbethClient } from './VerbethClient.js';

package/dist/src/client/types.d.ts

@@ -0,0 +1,30 @@
+import type { Signer } from 'ethers';
+import type { IExecutor } from '../executor.js';
+import type { IdentityKeyPair, IdentityProof, DuplexTopics } from '../types.js';
+import type nacl from 'tweetnacl';
+/**
+ * Configuration for creating a VerbethClient instance
+ */
+export interface VerbethClientConfig {
+    executor: IExecutor;
+    identityKeyPair: IdentityKeyPair;
+    identityProof: IdentityProof;
+    signer: Signer;
+    address: string;
+}
+/**
+ * Result from initiating a handshake
+ */
+export interface HandshakeResult {
+    tx: any;
+    ephemeralKeyPair: nacl.BoxKeyPair;
+}
+/**
+ * Result from accepting a handshake
+ */
+export interface HandshakeResponseResult {
+    tx: any;
+    duplexTopics: DuplexTopics;
+    tag: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/client/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,SAAS,CAAC;IACpB,eAAe,EAAE,eAAe,CAAC;IACjC,aAAa,EAAE,aAAa,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,GAAG,CAAC;IACR,gBAAgB,EAAE,IAAI,CAAC,UAAU,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,GAAG,CAAC;IACR,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;CACb"}

package/dist/src/client/types.js

@@ -0,0 +1,2 @@
+// packages/sdk/src/client/types.ts
+export {};

package/dist/src/crypto.d.ts

@@ -0,0 +1,46 @@
+import { HandshakeResponseContent } from './payload.js';
+import { IdentityProof } from './types.js';
+/**
+ * Encrypts a structured payload (JSON-serializable objects)
+ */
+export declare function encryptStructuredPayload<T>(payload: T, recipientPublicKey: Uint8Array, ephemeralSecretKey: Uint8Array, ephemeralPublicKey: Uint8Array, staticSigningSecretKey?: Uint8Array, staticSigningPublicKey?: Uint8Array): string;
+/**
+ * Decrypts a structured payload with converter function
+ */
+export declare function decryptStructuredPayload<T>(payloadJson: string, recipientSecretKey: Uint8Array, converter: (obj: any) => T, staticSigningPublicKey?: Uint8Array): T | null;
+export declare function encryptMessage(message: string, recipientPublicKey: Uint8Array, ephemeralSecretKey: Uint8Array, ephemeralPublicKey: Uint8Array, staticSigningSecretKey?: Uint8Array, staticSigningPublicKey?: Uint8Array): string;
+export declare function decryptMessage(payloadJson: string, recipientSecretKey: Uint8Array, staticSigningPublicKey?: Uint8Array): string | null;
+/**
+ * Decrypts handshake response and extracts individual keys from unified format
+ */
+export declare function decryptHandshakeResponse(payloadJson: string, initiatorEphemeralSecretKey: Uint8Array): HandshakeResponseContent | null;
+/**
+ * helper to decrypt handshake response and extract individual keys
+ */
+export declare function decryptAndExtractHandshakeKeys(payloadJson: string, initiatorEphemeralSecretKey: Uint8Array): {
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+    ephemeralPubKey: Uint8Array;
+    note?: string;
+    identityProof: IdentityProof;
+} | null;
+/**
+ * Responder: tag = H( KDF( ECDH(r, viewPubA), "verbeth:hsr"))
+ */
+export declare function computeTagFromResponder(rSecretKey: Uint8Array, viewPubA: Uint8Array): `0x${string}`;
+/**
+ * Initiator: tag = H( KDF( ECDH(viewPrivA, R), "verbeth:hsr"))
+ */
+export declare function computeTagFromInitiator(viewPrivA: Uint8Array, R: Uint8Array): `0x${string}`;
+export declare function deriveLongTermShared(myIdentitySecretKey: Uint8Array, theirIdentityPublicKey: Uint8Array): Uint8Array;
+/**
+ * Directional duplex topics (Initiator-Responder, Responder-Initiator).
+ * Recommended salt: tag (bytes)
+ */
+export declare function deriveDuplexTopics(myIdentitySecretKey: Uint8Array, theirIdentityPublicKey: Uint8Array, salt?: Uint8Array): {
+    topicOut: `0x${string}`;
+    topicIn: `0x${string}`;
+    checksum: `0x${string}`;
+};
+export declare function verifyDuplexTopicsChecksum(topicOut: `0x${string}`, topicIn: `0x${string}`, checksum: `0x${string}`): boolean;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/src/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/crypto.ts"],"names":[],"mappings":"AAMA,OAAO,EAML,wBAAwB,EAEzB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,OAAO,EAAE,CAAC,EACV,kBAAkB,EAAE,UAAU,EAC9B,kBAAkB,EAAE,UAAU,EAC9B,kBAAkB,EAAE,UAAU,EAC9B,sBAAsB,CAAC,EAAE,UAAU,EACnC,sBAAsB,CAAC,EAAE,UAAU,GAClC,MAAM,CAcR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,UAAU,EAC9B,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,EAC1B,sBAAsB,CAAC,EAAE,UAAU,GAClC,CAAC,GAAG,IAAI,CAaV;AAGD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,UAAU,EAC9B,kBAAkB,EAAE,UAAU,EAC9B,kBAAkB,EAAE,UAAU,EAC9B,sBAAsB,CAAC,EAAE,UAAU,EACnC,sBAAsB,CAAC,EAAE,UAAU,GAClC,MAAM,CAUR;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,UAAU,EAC9B,sBAAsB,CAAC,EAAE,UAAU,GAClC,MAAM,GAAG,IAAI,CAQf;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,2BAA2B,EAAE,UAAU,GACtC,wBAAwB,GAAG,IAAI,CAgBjC;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,2BAA2B,EAAE,UAAU,GACtC;IACD,cAAc,EAAE,UAAU,CAAC;IAC3B,aAAa,EAAE,UAAU,CAAC;IAC1B,eAAe,EAAE,UAAU,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,aAAa,CAAC;CAC9B,GAAG,IAAI,CAcP;AAWD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,UAAU,GACnB,KAAK,MAAM,EAAE,CAGf;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,UAAU,EACrB,CAAC,EAAE,UAAU,GACZ,KAAK,MAAM,EAAE,CAGf;AAkBD,wBAAgB,oBAAoB,CAClC,mBAAmB,EAAE,UAAU,EAC/B,sBAAsB,EAAE,UAAU,GACjC,UAAU,CAEZ;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,UAAU,EAC/B,sBAAsB,EAAE,UAAU,EAClC,IAAI,CAAC,EAAE,UAAU,GAChB;IAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAA;CAAE,CAW9E;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,MAAM,EAAE,EACvB,OAAO,EAAE,KAAK,MAAM,EAAE,EACtB,QAAQ,EAAE,KAAK,MAAM,EAAE,GACtB,OAAO,CAOT"}

package/dist/src/crypto.js

@@ -0,0 +1,137 @@
+// packages/sdk/src/crypto.ts
+import nacl from 'tweetnacl';
+import { keccak256, toUtf8Bytes, dataSlice } from 'ethers';
+import { sha256 } from '@noble/hashes/sha2';
+import { hkdf } from '@noble/hashes/hkdf';
+import { encodePayload, decodePayload, encodeStructuredContent, decodeStructuredContent, extractKeysFromHandshakeResponse } from './payload.js';
+/**
+ * Encrypts a structured payload (JSON-serializable objects)
+ */
+export function encryptStructuredPayload(payload, recipientPublicKey, ephemeralSecretKey, ephemeralPublicKey, staticSigningSecretKey, staticSigningPublicKey) {
+    // encode payload as binary JSON
+    const plaintext = encodeStructuredContent(payload);
+    const nonce = nacl.randomBytes(nacl.box.nonceLength);
+    const box = nacl.box(plaintext, nonce, recipientPublicKey, ephemeralSecretKey);
+    let sig;
+    if (staticSigningSecretKey && staticSigningPublicKey) {
+        const dataToSign = Buffer.concat([ephemeralPublicKey, nonce, box]);
+        sig = nacl.sign.detached(dataToSign, staticSigningSecretKey);
+    }
+    return encodePayload(ephemeralPublicKey, nonce, box, sig);
+}
+/**
+ * Decrypts a structured payload with converter function
+ */
+export function decryptStructuredPayload(payloadJson, recipientSecretKey, converter, staticSigningPublicKey) {
+    const { epk, nonce, ciphertext, sig } = decodePayload(payloadJson);
+    if (sig && staticSigningPublicKey) {
+        const dataToVerify = Buffer.concat([epk, nonce, ciphertext]);
+        const valid = nacl.sign.detached.verify(dataToVerify, sig, staticSigningPublicKey);
+        if (!valid)
+            return null;
+    }
+    const box = nacl.box.open(ciphertext, nonce, epk, recipientSecretKey);
+    if (!box)
+        return null;
+    return decodeStructuredContent(box, converter);
+}
+//  wrappers for encrypting and decrypting messages
+export function encryptMessage(message, recipientPublicKey, ephemeralSecretKey, ephemeralPublicKey, staticSigningSecretKey, staticSigningPublicKey) {
+    const payload = { content: message };
+    return encryptStructuredPayload(payload, recipientPublicKey, ephemeralSecretKey, ephemeralPublicKey, staticSigningSecretKey, staticSigningPublicKey);
+}
+export function decryptMessage(payloadJson, recipientSecretKey, staticSigningPublicKey) {
+    const result = decryptStructuredPayload(payloadJson, recipientSecretKey, (obj) => obj, staticSigningPublicKey);
+    return result ? result.content : null;
+}
+/**
+ * Decrypts handshake response and extracts individual keys from unified format
+ */
+export function decryptHandshakeResponse(payloadJson, initiatorEphemeralSecretKey) {
+    return decryptStructuredPayload(payloadJson, initiatorEphemeralSecretKey, (obj) => {
+        if (!obj.identityProof) {
+            throw new Error("Invalid handshake response: missing identityProof");
+        }
+        return {
+            unifiedPubKeys: Uint8Array.from(Buffer.from(obj.unifiedPubKeys, 'base64')),
+            ephemeralPubKey: Uint8Array.from(Buffer.from(obj.ephemeralPubKey, 'base64')),
+            note: obj.note,
+            identityProof: obj.identityProof
+        };
+    });
+}
+/**
+ * helper to decrypt handshake response and extract individual keys
+ */
+export function decryptAndExtractHandshakeKeys(payloadJson, initiatorEphemeralSecretKey) {
+    const decrypted = decryptHandshakeResponse(payloadJson, initiatorEphemeralSecretKey);
+    if (!decrypted)
+        return null;
+    const extracted = extractKeysFromHandshakeResponse(decrypted);
+    if (!extracted)
+        return null;
+    return {
+        identityPubKey: extracted.identityPubKey,
+        signingPubKey: extracted.signingPubKey,
+        ephemeralPubKey: extracted.ephemeralPubKey,
+        note: decrypted.note,
+        identityProof: decrypted.identityProof
+    };
+}
+/**
+ * HKDF(sha256) on shared secret, info="verbeth:hsr", then Keccak-256 -> bytes32 (0x...)
+ */
+function finalizeHsrTag(shared) {
+    const okm = hkdf(sha256, shared, new Uint8Array(0), toUtf8Bytes("verbeth:hsr"), 32);
+    return keccak256(okm);
+}
+/**
+ * Responder: tag = H( KDF( ECDH(r, viewPubA), "verbeth:hsr"))
+ */
+export function computeTagFromResponder(rSecretKey, viewPubA) {
+    const shared = nacl.scalarMult(rSecretKey, viewPubA);
+    return finalizeHsrTag(shared);
+}
+/**
+ * Initiator: tag = H( KDF( ECDH(viewPrivA, R), "verbeth:hsr"))
+ */
+export function computeTagFromInitiator(viewPrivA, R) {
+    const shared = nacl.scalarMult(viewPrivA, R);
+    return finalizeHsrTag(shared);
+}
+/**
+ * Derives a bytes32 topic from the shared secret via HKDF(SHA256) + Keccak-256.
+ * - info: domain separation (e.g., "verbeth:topic-out:v1")
+ * - salt: recommended to use a tag as salt (stable and shareable)
+ */
+function deriveTopic(shared, info, salt) {
+    const okm = hkdf(sha256, shared, salt ?? new Uint8Array(0), new TextEncoder().encode(info), 32);
+    return keccak256(okm);
+}
+export function deriveLongTermShared(myIdentitySecretKey, theirIdentityPublicKey) {
+    return nacl.scalarMult(myIdentitySecretKey, theirIdentityPublicKey);
+}
+/**
+ * Directional duplex topics (Initiator-Responder, Responder-Initiator).
+ * Recommended salt: tag (bytes)
+ */
+export function deriveDuplexTopics(myIdentitySecretKey, theirIdentityPublicKey, salt) {
+    const shared = deriveLongTermShared(myIdentitySecretKey, theirIdentityPublicKey);
+    const topicOut = deriveTopic(shared, "verbeth:topic-out:v1", salt);
+    const topicIn = deriveTopic(shared, "verbeth:topic-in:v1", salt);
+    const chkFull = keccak256(Buffer.concat([
+        toUtf8Bytes("verbeth:topic-chk:v1"),
+        Buffer.from(topicOut.slice(2), 'hex'),
+        Buffer.from(topicIn.slice(2), 'hex'),
+    ]));
+    const checksum = dataSlice(chkFull, 8);
+    return { topicOut, topicIn, checksum };
+}
+export function verifyDuplexTopicsChecksum(topicOut, topicIn, checksum) {
+    const chkFull = keccak256(Buffer.concat([
+        toUtf8Bytes("verbeth:topic-chk:v1"),
+        Buffer.from(topicOut.slice(2), 'hex'),
+        Buffer.from(topicIn.slice(2), 'hex'),
+    ]));
+    return dataSlice(chkFull, 8) === checksum;
+}

package/dist/src/executor.d.ts

@@ -0,0 +1,73 @@
+import { Signer, Contract, BaseContract } from "ethers";
+import type { LogChainV1 } from "@verbeth/contracts/typechain-types";
+export declare function split128x128(word: bigint): readonly [bigint, bigint];
+export interface IExecutor {
+    sendMessage(ciphertext: Uint8Array, topic: string, timestamp: number, nonce: bigint): Promise<any>;
+    initiateHandshake(recipientHash: string, pubKeys: string, ephemeralPubKey: string, plaintextPayload: Uint8Array): Promise<any>;
+    respondToHandshake(inResponseTo: string, responderEphemeralR: string, ciphertext: Uint8Array): Promise<any>;
+}
+export declare class EOAExecutor implements IExecutor {
+    private contract;
+    constructor(contract: LogChainV1);
+    sendMessage(ciphertext: Uint8Array, topic: string, timestamp: number, nonce: bigint): Promise<any>;
+    initiateHandshake(recipientHash: string, pubKeys: string, ephemeralPubKey: string, plaintextPayload: Uint8Array): Promise<any>;
+    respondToHandshake(inResponseTo: string, responderEphemeralR: string, ciphertext: Uint8Array): Promise<any>;
+}
+export declare class BaseSmartAccountExecutor implements IExecutor {
+    private baseAccountProvider;
+    private logChainAddress;
+    private paymasterServiceUrl?;
+    private subAccountAddress?;
+    private logChainInterface;
+    private chainId;
+    constructor(baseAccountProvider: any, logChainAddress: string, chainId?: number, // Base mainnet by default
+    paymasterServiceUrl?: string | undefined, subAccountAddress?: string | undefined);
+    sendMessage(ciphertext: Uint8Array, topic: string, timestamp: number, nonce: bigint): Promise<any>;
+    initiateHandshake(recipientHash: string, pubKeys: string, ephemeralPubKey: string, plaintextPayload: Uint8Array): Promise<any>;
+    respondToHandshake(inResponseTo: string, responderEphemeralR: string, ciphertext: Uint8Array): Promise<any>;
+    private executeCalls;
+}
+export declare class UserOpExecutor implements IExecutor {
+    private smartAccountAddress;
+    private logChainAddress;
+    private bundlerClient;
+    private smartAccountClient;
+    private logChainInterface;
+    private smartAccountInterface;
+    constructor(smartAccountAddress: string, logChainAddress: string, bundlerClient: any, smartAccountClient: any);
+    sendMessage(ciphertext: Uint8Array, topic: string, timestamp: number, nonce: bigint): Promise<any>;
+    initiateHandshake(recipientHash: string, pubKeys: string, ephemeralPubKey: string, plaintextPayload: Uint8Array): Promise<any>;
+    respondToHandshake(inResponseTo: string, responderEphemeralR: string, ciphertext: Uint8Array): Promise<any>;
+    private executeUserOp;
+}
+export declare class DirectEntryPointExecutor implements IExecutor {
+    private smartAccountAddress;
+    private logChainAddress;
+    private smartAccountClient;
+    private signer;
+    private logChainInterface;
+    private smartAccountInterface;
+    private entryPointContract;
+    private spec;
+    constructor(smartAccountAddress: string, entryPointContract: Contract | BaseContract, logChainAddress: string, smartAccountClient: any, signer: Signer);
+    sendMessage(ciphertext: Uint8Array, topic: string, timestamp: number, nonce: bigint): Promise<any>;
+    initiateHandshake(recipientHash: string, pubKeys: string, ephemeralPubKey: string, plaintextPayload: Uint8Array): Promise<any>;
+    respondToHandshake(inResponseTo: string, responderEphemeralR: string, ciphertext: Uint8Array): Promise<any>;
+    private executeDirectUserOp;
+}
+export declare class ExecutorFactory {
+    static createEOA(contract: LogChainV1): IExecutor;
+    static createBaseSmartAccount(baseAccountProvider: any, logChainAddress: string, chainId?: number, paymasterServiceUrl?: string, subAccountAddress?: string): IExecutor;
+    static createUserOp(smartAccountAddress: string, _entryPointAddress: string, logChainAddress: string, bundlerClient: any, smartAccountClient: any): IExecutor;
+    static createDirectEntryPoint(smartAccountAddress: string, entryPointContract: Contract | BaseContract, logChainAddress: string, smartAccountClient: any, signer: Signer): IExecutor;
+    static createAuto(signerOrAccount: any, contract: LogChainV1, options?: {
+        entryPointAddress?: string;
+        entryPointContract?: Contract | BaseContract;
+        logChainAddress?: string;
+        bundlerClient?: any;
+        baseAccountProvider?: any;
+        chainId?: number;
+        isTestEnvironment?: boolean;
+    }): Promise<IExecutor>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/src/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/executor.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,MAAM,EACN,QAAQ,EAER,YAAY,EAGb,MAAM,QAAQ,CAAC;AAOhB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAOrE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAGpE;AA0BD,MAAM,WAAW,SAAS;IACxB,WAAW,CACT,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC,CAAC;IAEhB,iBAAiB,CACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,UAAU,GAC3B,OAAO,CAAC,GAAG,CAAC,CAAC;IAEhB,kBAAkB,CAChB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC,CAAC;CACjB;AAGD,qBAAa,WAAY,YAAW,SAAS;IAC/B,OAAO,CAAC,QAAQ;gBAAR,QAAQ,EAAE,UAAU;IAElC,WAAW,CACf,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC;IAIT,iBAAiB,CACrB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,UAAU,GAC3B,OAAO,CAAC,GAAG,CAAC;IAST,kBAAkB,CACtB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC;CAGhB;AAGD,qBAAa,wBAAyB,YAAW,SAAS;IAKtD,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,eAAe;IAEvB,OAAO,CAAC,mBAAmB,CAAC;IAC5B,OAAO,CAAC,iBAAiB,CAAC;IAR5B,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,OAAO,CAAS;gBAGd,mBAAmB,EAAE,GAAG,EACxB,eAAe,EAAE,MAAM,EAC/B,OAAO,SAAO,EAAE,0BAA0B;IAClC,mBAAmB,CAAC,EAAE,MAAM,YAAA,EAC5B,iBAAiB,CAAC,EAAE,MAAM,YAAA;IAiB9B,WAAW,CACf,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC;IAiBT,iBAAiB,CACrB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,UAAU,GAC3B,OAAO,CAAC,GAAG,CAAC;IAeT,kBAAkB,CACtB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC;YAeD,YAAY;CAkD3B;AAGD,qBAAa,cAAe,YAAW,SAAS;IAK5C,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,kBAAkB;IAP5B,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,qBAAqB,CAAY;gBAG/B,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,GAAG,EAClB,kBAAkB,EAAE,GAAG;IAc3B,WAAW,CACf,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC;IAkBT,iBAAiB,CACrB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,UAAU,GAC3B,OAAO,CAAC,GAAG,CAAC;IAkBT,kBAAkB,CACtB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC;YAkBD,aAAa;CA8B5B;AAGD,qBAAa,wBAAyB,YAAW,SAAS;IAOtD,OAAO,CAAC,mBAAmB;IAE3B,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,MAAM;IAVhB,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,qBAAqB,CAAY;IACzC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,IAAI,CAAgB;gBAGlB,mBAAmB,EAAE,MAAM,EACnC,kBAAkB,EAAE,QAAQ,GAAG,YAAY,EACnC,eAAe,EAAE,MAAM,EACvB,kBAAkB,EAAE,GAAG,EACvB,MAAM,EAAE,MAAM;IAiBlB,WAAW,CACf,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC;IAkBT,iBAAiB,CACrB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,UAAU,GAC3B,OAAO,CAAC,GAAG,CAAC;IAkBT,kBAAkB,CACtB,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,GAAG,CAAC;YAkBD,mBAAmB;CAoDlC;AAED,qBAAa,eAAe;IAC1B,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,SAAS;IAIjD,MAAM,CAAC,sBAAsB,CAC3B,mBAAmB,EAAE,GAAG,EACxB,eAAe,EAAE,MAAM,EACvB,OAAO,SAAO,EACd,mBAAmB,CAAC,EAAE,MAAM,EAC5B,iBAAiB,CAAC,EAAE,MAAM,GACzB,SAAS;IAUZ,MAAM,CAAC,YAAY,CACjB,mBAAmB,EAAE,MAAM,EAC3B,kBAAkB,EAAE,MAAM,EAC1B,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,GAAG,EAClB,kBAAkB,EAAE,GAAG,GACtB,SAAS;IASZ,MAAM,CAAC,sBAAsB,CAC3B,mBAAmB,EAAE,MAAM,EAC3B,kBAAkB,EAAE,QAAQ,GAAG,YAAY,EAC3C,eAAe,EAAE,MAAM,EACvB,kBAAkB,EAAE,GAAG,EACvB,MAAM,EAAE,MAAM,GACb,SAAS;WAWC,UAAU,CACrB,eAAe,EAAE,GAAG,EACpB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE;QACR,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,kBAAkB,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;QAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,GAAG,CAAC;QACpB,mBAAmB,CAAC,EAAE,GAAG,CAAC;QAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B,GACA,OAAO,CAAC,SAAS,CAAC;CAkEtB"}