@verbeth/sdk 0.1.4

package/dist/src/executor.js

@@ -0,0 +1,353 @@
+// packages/sdk/src/executor.ts
+import { Interface, toBeHex, zeroPadValue, } from "ethers";
+function pack128x128(high, low) {
+    return (high << 128n) | (low & ((1n << 128n) - 1n));
+}
+// Unpack a packed 256-bit value into two 128-bit values
+export function split128x128(word) {
+    const lowMask = (1n << 128n) - 1n;
+    return [word >> 128n, word & lowMask];
+}
+/* -------------------------------------------------------------------------- */
+/*    Helpers for compatibility between AA spec v0.6 and v0.7                 */
+/* -------------------------------------------------------------------------- */
+const detectSpecVersion = (iface) => {
+    try {
+        iface.getFunction("getAccountGasLimits");
+        return "v0.7";
+    }
+    catch {
+        return "v0.6";
+    }
+};
+// transforms all bigints into padded bytes32 (uint256)
+const padBigints = (op) => {
+    const out = { ...op };
+    for (const [k, v] of Object.entries(out)) {
+        if (typeof v === "bigint") {
+            out[k] = zeroPadValue(toBeHex(v), 32);
+        }
+    }
+    return out;
+};
+// EOA Executor - Direct contract calls via wallet signer
+export class EOAExecutor {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async sendMessage(ciphertext, topic, timestamp, nonce) {
+        return this.contract.sendMessage(ciphertext, topic, timestamp, nonce);
+    }
+    async initiateHandshake(recipientHash, pubKeys, ephemeralPubKey, plaintextPayload) {
+        return this.contract.initiateHandshake(recipientHash, pubKeys, ephemeralPubKey, plaintextPayload);
+    }
+    async respondToHandshake(inResponseTo, responderEphemeralR, ciphertext) {
+        return this.contract.respondToHandshake(inResponseTo, responderEphemeralR, ciphertext);
+    }
+}
+// Base Smart Account Executor - Uses wallet_sendCalls for sponsored transactions
+export class BaseSmartAccountExecutor {
+    constructor(baseAccountProvider, logChainAddress, chainId = 8453, // Base mainnet by default
+    paymasterServiceUrl, subAccountAddress) {
+        this.baseAccountProvider = baseAccountProvider;
+        this.logChainAddress = logChainAddress;
+        this.paymasterServiceUrl = paymasterServiceUrl;
+        this.subAccountAddress = subAccountAddress;
+        this.logChainInterface = new Interface([
+            "function sendMessage(bytes calldata ciphertext, bytes32 topic, uint256 timestamp, uint256 nonce)",
+            "function initiateHandshake(bytes32 recipientHash, bytes pubKeys, bytes ephemeralPubKey, bytes plaintextPayload)",
+            "function respondToHandshake(bytes32 inResponseTo, bytes32 responderEphemeralR, bytes ciphertext)",
+        ]);
+        // Convert chainId to hex
+        this.chainId =
+            chainId === 8453
+                ? "0x2105" // Base mainnet
+                : chainId === 84532
+                    ? "0x14a34" // Base Sepolia
+                    : `0x${chainId.toString(16)}`;
+    }
+    async sendMessage(ciphertext, topic, timestamp, nonce) {
+        const callData = this.logChainInterface.encodeFunctionData("sendMessage", [
+            ciphertext,
+            topic,
+            timestamp,
+            nonce,
+        ]);
+        return this.executeCalls([
+            {
+                to: this.logChainAddress,
+                value: "0x0",
+                data: callData,
+            },
+        ]);
+    }
+    async initiateHandshake(recipientHash, pubKeys, ephemeralPubKey, plaintextPayload) {
+        const callData = this.logChainInterface.encodeFunctionData("initiateHandshake", [recipientHash, pubKeys, ephemeralPubKey, plaintextPayload]);
+        return this.executeCalls([
+            {
+                to: this.logChainAddress,
+                value: "0x0",
+                data: callData,
+            },
+        ]);
+    }
+    async respondToHandshake(inResponseTo, responderEphemeralR, ciphertext) {
+        const callData = this.logChainInterface.encodeFunctionData("respondToHandshake", [inResponseTo, responderEphemeralR, ciphertext]);
+        return this.executeCalls([
+            {
+                to: this.logChainAddress,
+                value: "0x0",
+                data: callData,
+            },
+        ]);
+    }
+    async executeCalls(calls) {
+        try {
+            //console.log("DEBUG: Sub account address:", this.subAccountAddress);
+            const requestParams = {
+                version: "1.0",
+                chainId: this.chainId,
+                calls,
+            };
+            //** WORK IN PROGRESS */
+            if (this.subAccountAddress) {
+                requestParams.from = this.subAccountAddress;
+                //console.log("DEBUG: Using sub account for transaction");
+            }
+            if (this.paymasterServiceUrl) {
+                requestParams.capabilities = {
+                    paymasterService: {
+                        url: this.paymasterServiceUrl,
+                    },
+                };
+                //console.log("DEBUG: Using paymaster for gas sponsorship");
+            }
+            //console.log("DEBUG: Request params:", requestParams);
+            const result = await this.baseAccountProvider.request({
+                method: "wallet_sendCalls",
+                params: [requestParams],
+            });
+            // first 32 bytes are the actual userop hash
+            if (typeof result === "string" &&
+                result.startsWith("0x") &&
+                result.length > 66) {
+                const actualTxHash = "0x" + result.slice(2, 66); // Extract first 32 bytes
+                //console.log("DEBUG: extracted tx hash:", actualTxHash);
+                return { hash: actualTxHash };
+            }
+            return result;
+        }
+        catch (error) {
+            console.error("Base Smart Account transaction failed:", error);
+            throw error;
+        }
+    }
+}
+// UserOp Executor - Account Abstraction via bundler
+export class UserOpExecutor {
+    constructor(smartAccountAddress, logChainAddress, bundlerClient, smartAccountClient) {
+        this.smartAccountAddress = smartAccountAddress;
+        this.logChainAddress = logChainAddress;
+        this.bundlerClient = bundlerClient;
+        this.smartAccountClient = smartAccountClient;
+        this.logChainInterface = new Interface([
+            "function sendMessage(bytes calldata ciphertext, bytes32 topic, uint256 timestamp, uint256 nonce)",
+            "function initiateHandshake(bytes32 recipientHash, bytes pubKeys, bytes ephemeralPubKey, bytes plaintextPayload)",
+            "function respondToHandshake(bytes32 inResponseTo, bytes32 responderEphemeralR, bytes ciphertext)",
+        ]);
+        // Smart account interface for executing calls to other contracts
+        this.smartAccountInterface = new Interface([
+            "function execute(address target, uint256 value, bytes calldata data) returns (bytes)",
+        ]);
+    }
+    async sendMessage(ciphertext, topic, timestamp, nonce) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("sendMessage", [ciphertext, topic, timestamp, nonce]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeUserOp(smartAccountCallData);
+    }
+    async initiateHandshake(recipientHash, pubKeys, ephemeralPubKey, plaintextPayload) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("initiateHandshake", [recipientHash, pubKeys, ephemeralPubKey, plaintextPayload]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeUserOp(smartAccountCallData);
+    }
+    async respondToHandshake(inResponseTo, responderEphemeralR, ciphertext) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("respondToHandshake", [inResponseTo, responderEphemeralR, ciphertext]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeUserOp(smartAccountCallData);
+    }
+    async executeUserOp(callData) {
+        const callGasLimit = 1000000n;
+        const verificationGasLimit = 1000000n;
+        const maxFeePerGas = 1000000000n;
+        const maxPriorityFeePerGas = 1000000000n;
+        const userOp = {
+            sender: this.smartAccountAddress,
+            nonce: await this.smartAccountClient.getNonce(),
+            initCode: "0x", // No init code for existing accounts
+            callData,
+            accountGasLimits: pack128x128(verificationGasLimit, callGasLimit),
+            preVerificationGas: 100000n,
+            gasFees: pack128x128(maxFeePerGas, maxPriorityFeePerGas),
+            paymasterAndData: "0x",
+            signature: "0x",
+        };
+        const signedUserOp = await this.smartAccountClient.signUserOperation(userOp);
+        const userOpHash = await this.bundlerClient.sendUserOperation(signedUserOp);
+        const receipt = await this.bundlerClient.waitForUserOperationReceipt(userOpHash);
+        return receipt;
+    }
+}
+// Direct EntryPoint Executor - for local testing (bypasses bundler)
+export class DirectEntryPointExecutor {
+    constructor(smartAccountAddress, entryPointContract, logChainAddress, smartAccountClient, signer) {
+        this.smartAccountAddress = smartAccountAddress;
+        this.logChainAddress = logChainAddress;
+        this.smartAccountClient = smartAccountClient;
+        this.signer = signer;
+        this.logChainInterface = new Interface([
+            "function sendMessage(bytes calldata ciphertext, bytes32 topic, uint256 timestamp, uint256 nonce)",
+            "function initiateHandshake(bytes32 recipientHash, bytes pubKeys, bytes ephemeralPubKey, bytes plaintextPayload)",
+            "function respondToHandshake(bytes32 inResponseTo, bytes32 responderEphemeralR, bytes ciphertext)",
+        ]);
+        // Smart account interface for executing calls to other contracts
+        this.smartAccountInterface = new Interface([
+            "function execute(address target, uint256 value, bytes calldata data) returns (bytes)",
+        ]);
+        this.entryPointContract = entryPointContract.connect(signer);
+        this.spec = detectSpecVersion(this.entryPointContract.interface);
+    }
+    async sendMessage(ciphertext, topic, timestamp, nonce) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("sendMessage", [ciphertext, topic, timestamp, nonce]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeDirectUserOp(smartAccountCallData);
+    }
+    async initiateHandshake(recipientHash, pubKeys, ephemeralPubKey, plaintextPayload) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("initiateHandshake", [recipientHash, pubKeys, ephemeralPubKey, plaintextPayload]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeDirectUserOp(smartAccountCallData);
+    }
+    async respondToHandshake(inResponseTo, responderEphemeralR, ciphertext) {
+        const logChainCallData = this.logChainInterface.encodeFunctionData("respondToHandshake", [inResponseTo, responderEphemeralR, ciphertext]);
+        const smartAccountCallData = this.smartAccountInterface.encodeFunctionData("execute", [
+            this.logChainAddress,
+            0, // value
+            logChainCallData,
+        ]);
+        return this.executeDirectUserOp(smartAccountCallData);
+    }
+    async executeDirectUserOp(callData) {
+        const callGasLimit = 1000000n;
+        const verificationGasLimit = 1000000n;
+        const maxFeePerGas = 1000000000n;
+        const maxPriorityFeePerGas = 1000000000n;
+        // Build UserOperation
+        let userOp;
+        if (this.spec === "v0.6") {
+            userOp = {
+                sender: this.smartAccountAddress,
+                nonce: await this.smartAccountClient.getNonce(),
+                initCode: "0x",
+                callData,
+                callGasLimit,
+                verificationGasLimit,
+                preVerificationGas: 100000n,
+                maxFeePerGas,
+                maxPriorityFeePerGas,
+                paymasterAndData: "0x",
+                signature: "0x",
+            };
+        }
+        else {
+            userOp = {
+                sender: this.smartAccountAddress,
+                nonce: await this.smartAccountClient.getNonce(),
+                initCode: "0x",
+                callData,
+                accountGasLimits: pack128x128(verificationGasLimit, callGasLimit),
+                preVerificationGas: 100000n,
+                gasFees: pack128x128(maxFeePerGas, maxPriorityFeePerGas),
+                paymasterAndData: "0x",
+                signature: "0x",
+            };
+        }
+        // Pad bigints, bytes32 before signing
+        const paddedUserOp = padBigints(userOp);
+        //console.log("Padded UserOp:", paddedUserOp);
+        const signed = await this.smartAccountClient.signUserOperation(paddedUserOp);
+        // Direct submit to EntryPoint
+        const tx = await this.entryPointContract.handleOps([signed], await this.signer.getAddress());
+        return tx;
+    }
+}
+export class ExecutorFactory {
+    static createEOA(contract) {
+        return new EOAExecutor(contract);
+    }
+    static createBaseSmartAccount(baseAccountProvider, logChainAddress, chainId = 8453, paymasterServiceUrl, subAccountAddress) {
+        return new BaseSmartAccountExecutor(baseAccountProvider, logChainAddress, chainId, paymasterServiceUrl, subAccountAddress);
+    }
+    static createUserOp(smartAccountAddress, _entryPointAddress, logChainAddress, bundlerClient, smartAccountClient) {
+        return new UserOpExecutor(smartAccountAddress, logChainAddress, bundlerClient, smartAccountClient);
+    }
+    static createDirectEntryPoint(smartAccountAddress, entryPointContract, logChainAddress, smartAccountClient, signer) {
+        return new DirectEntryPointExecutor(smartAccountAddress, entryPointContract, logChainAddress, smartAccountClient, signer);
+    }
+    // Auto-detect executor based on environment and signer type
+    static async createAuto(signerOrAccount, contract, options) {
+        if (options?.baseAccountProvider && options?.logChainAddress) {
+            return new BaseSmartAccountExecutor(options.baseAccountProvider, options.logChainAddress, options.chainId || 8453);
+        }
+        try {
+            const provider = signerOrAccount?.provider || signerOrAccount;
+            if (provider && typeof provider.request === "function") {
+                // test if provider supports wallet_sendCalls
+                const capabilities = await provider
+                    .request({
+                    method: "wallet_getCapabilities",
+                    params: [],
+                })
+                    .catch(() => null);
+                if (capabilities && options?.logChainAddress) {
+                    // if wallet supports capabilities, it's likely a Base Smart Account
+                    return new BaseSmartAccountExecutor(provider, options.logChainAddress, options.chainId || 8453);
+                }
+            }
+        }
+        catch (error) { }
+        if (signerOrAccount.address &&
+            (options?.bundlerClient || options?.entryPointContract)) {
+            if (options.isTestEnvironment &&
+                options.entryPointContract &&
+                options.logChainAddress) {
+                return new DirectEntryPointExecutor(signerOrAccount.address, options.entryPointContract, options.logChainAddress, signerOrAccount, signerOrAccount.signer || signerOrAccount);
+            }
+            if (options.bundlerClient &&
+                options.entryPointAddress &&
+                options.logChainAddress) {
+                return new UserOpExecutor(signerOrAccount.address, options.logChainAddress, options.bundlerClient, signerOrAccount);
+            }
+        }
+        // default to EOA executor
+        return new EOAExecutor(contract);
+    }
+}

package/dist/src/identity.d.ts

@@ -0,0 +1,28 @@
+import { Signer } from "ethers";
+import { IdentityProof } from "./types.js";
+interface IdentityKeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+    signingPublicKey: Uint8Array;
+    signingSecretKey: Uint8Array;
+}
+/**
+ * HKDF (RFC 5869) identity key derivation.
+ * Returns a proof binding the derived keypair to the wallet address.
+ */
+export declare function deriveIdentityKeyPairWithProof(signer: any, address: string): Promise<{
+    keyPair: IdentityKeyPair;
+    identityProof: {
+        message: string;
+        signature: string;
+        messageRawHex?: `0x${string}`;
+    };
+}>;
+export declare function deriveIdentityWithUnifiedKeys(signer: Signer, address: string): Promise<{
+    identityProof: IdentityProof;
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+    unifiedPubKeys: Uint8Array;
+}>;
+export {};
+//# sourceMappingURL=identity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/identity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAmB,MAAM,QAAQ,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,UAAU,eAAe;IAEvB,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC;IAEtB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,gBAAgB,EAAE,UAAU,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,GAAG,EACX,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IACT,OAAO,EAAE,eAAe,CAAC;IACzB,aAAa,EAAE;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;KAC/B,CAAC;CACH,CAAC,CAyDD;AAED,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IACT,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,UAAU,CAAC;IAC3B,aAAa,EAAE,UAAU,CAAC;IAC1B,cAAc,EAAE,UAAU,CAAC;CAC5B,CAAC,CAcD"}

package/dist/src/identity.js

@@ -0,0 +1,70 @@
+import { sha256 } from "@noble/hashes/sha2";
+import { hkdf } from "@noble/hashes/hkdf";
+import { concat, hexlify } from "ethers";
+import nacl from "tweetnacl";
+import { encodeUnifiedPubKeys } from "./payload.js";
+/**
+ * HKDF (RFC 5869) identity key derivation.
+ * Returns a proof binding the derived keypair to the wallet address.
+ */
+export async function deriveIdentityKeyPairWithProof(signer, address) {
+    // 1) Local secret seed (32B CSPRNG), domain-separated by address
+    const r = nacl.randomBytes(32);
+    const enc = new TextEncoder();
+    const addrLower = address.toLowerCase();
+    // IKM = HKDF(r || "verbeth/addr:" || address_lower)
+    // salt/info are public domain labels
+    const seedSalt = enc.encode("verbeth/seed-v1");
+    const seedInfo = enc.encode("verbeth/ikm");
+    const ikmInput = concat([r, enc.encode("verbeth/addr:" + addrLower)]);
+    const ikm = hkdf(sha256, ikmInput, seedSalt, seedInfo, 32);
+    // Derive X25519 (encryption)
+    const info_x25519 = enc.encode("verbeth-x25519-v1");
+    const x25519_sk = hkdf(sha256, ikm, new Uint8Array(0), info_x25519, 32);
+    const boxKeyPair = nacl.box.keyPair.fromSecretKey(x25519_sk);
+    // Derive Ed25519 (signing)
+    const info_ed25519 = enc.encode("verbeth-ed25519-v1");
+    const ed25519_seed = hkdf(sha256, ikm, new Uint8Array(0), info_ed25519, 32);
+    const signKeyPair = nacl.sign.keyPair.fromSeed(ed25519_seed);
+    const pkX25519Hex = hexlify(boxKeyPair.publicKey);
+    const pkEd25519Hex = hexlify(signKeyPair.publicKey);
+    const keyPair = {
+        publicKey: boxKeyPair.publicKey,
+        secretKey: boxKeyPair.secretKey,
+        signingPublicKey: signKeyPair.publicKey,
+        signingSecretKey: signKeyPair.secretKey,
+    };
+    // 2) Single signature binding both public keys
+    const bindingMsgLines = [
+        "VerbEth Key Binding v1",
+        `Address: ${addrLower}`,
+        `PkEd25519: ${pkEd25519Hex}`,
+        `PkX25519: ${pkX25519Hex}`,
+        `Context: verbeth`,
+        `Version: 1`,
+    ];
+    const message = bindingMsgLines.join("\n");
+    const signature = await signer.signMessage(message);
+    const messageRawHex = ("0x" +
+        Buffer.from(message, "utf-8").toString("hex"));
+    return {
+        keyPair,
+        identityProof: {
+            message,
+            signature,
+            messageRawHex,
+        },
+    };
+}
+export async function deriveIdentityWithUnifiedKeys(signer, address) {
+    const result = await deriveIdentityKeyPairWithProof(signer, address);
+    const unifiedPubKeys = encodeUnifiedPubKeys(result.keyPair.publicKey, // X25519
+    result.keyPair.signingPublicKey // Ed25519
+    );
+    return {
+        identityProof: result.identityProof,
+        identityPubKey: result.keyPair.publicKey,
+        signingPubKey: result.keyPair.signingPublicKey,
+        unifiedPubKeys,
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+export * from './crypto.js';
+export * from './payload.js';
+export * from './send.js';
+export * from './verify.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './identity.js';
+export * from './executor.js';
+export { decryptMessage as decryptLog } from './crypto.js';
+export { getNextNonce } from './utils/nonce.js';
+export { encodeUnifiedPubKeys, decodeUnifiedPubKeys, createHandshakePayload, createHandshakeResponseContent, extractKeysFromHandshakePayload, extractKeysFromHandshakeResponse, parseHandshakeKeys } from './payload.js';
+export { decryptAndExtractHandshakeKeys, decryptMessage, decryptHandshakeResponse } from './crypto.js';
+export { verifyIdentityProof, verifyAndExtractHandshakeKeys, verifyAndExtractHandshakeResponseKeys } from './verify.js';
+export { deriveIdentityKeyPairWithProof, deriveIdentityWithUnifiedKeys } from './identity.js';
+export { IExecutor, EOAExecutor, UserOpExecutor, DirectEntryPointExecutor, ExecutorFactory } from './executor.js';
+export { VerbethClient } from './client/index.js';
+export type { VerbethClientConfig, HandshakeResult, HandshakeResponseResult } from './client/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAE9B,OAAO,EAAE,cAAc,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,8BAA8B,EAC9B,+BAA+B,EAC/B,gCAAgC,EAChC,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,8BAA8B,EAC9B,cAAc,EACd,wBAAwB,EACzB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,mBAAmB,EACnB,6BAA6B,EAC7B,qCAAqC,EACtC,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,SAAS,EACT,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,eAAe,EAChB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACxB,MAAM,mBAAmB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,17 @@
+export * from './crypto.js';
+export * from './payload.js';
+export * from './send.js';
+export * from './verify.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './identity.js';
+export * from './executor.js';
+export { decryptMessage as decryptLog } from './crypto.js';
+export { getNextNonce } from './utils/nonce.js';
+export { encodeUnifiedPubKeys, decodeUnifiedPubKeys, createHandshakePayload, createHandshakeResponseContent, extractKeysFromHandshakePayload, extractKeysFromHandshakeResponse, parseHandshakeKeys } from './payload.js';
+export { decryptAndExtractHandshakeKeys, decryptMessage, decryptHandshakeResponse } from './crypto.js';
+export { verifyIdentityProof, verifyAndExtractHandshakeKeys, verifyAndExtractHandshakeResponseKeys } from './verify.js';
+export { deriveIdentityKeyPairWithProof, deriveIdentityWithUnifiedKeys } from './identity.js';
+export { EOAExecutor, UserOpExecutor, DirectEntryPointExecutor, ExecutorFactory } from './executor.js';
+// high-level client API 
+export { VerbethClient } from './client/index.js';

package/dist/src/payload.d.ts

@@ -0,0 +1,94 @@
+import { IdentityProof, TopicInfoWire } from './types.js';
+export interface EncryptedPayload {
+    v: number;
+    epk: string;
+    n: string;
+    ct: string;
+    sig?: string;
+}
+export interface MessagePayload {
+    content: string;
+    timestamp?: number;
+    messageType?: 'text' | 'file' | 'media';
+    metadata?: Record<string, any>;
+}
+export interface HandshakeResponsePayload extends EncryptedPayload {
+}
+export interface HandshakeContent {
+    plaintextPayload: string;
+    identityProof: IdentityProof;
+}
+export declare function parseHandshakePayload(plaintextPayload: string): HandshakeContent;
+export declare function serializeHandshakeContent(content: HandshakeContent): string;
+export declare function encodePayload(ephemeralPubKey: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array, sig?: Uint8Array): string;
+export declare function decodePayload(json: string): {
+    epk: Uint8Array;
+    nonce: Uint8Array;
+    ciphertext: Uint8Array;
+    sig?: Uint8Array;
+};
+export declare function encodeStructuredContent<T>(content: T): Uint8Array;
+export declare function decodeStructuredContent<T>(encoded: Uint8Array, converter: (obj: any) => T): T;
+/**
+ * Encodes X25519 + Ed25519 keys into a single 65-byte array with versioning
+ */
+export declare function encodeUnifiedPubKeys(identityPubKey: Uint8Array, // X25519 - 32 bytes
+signingPubKey: Uint8Array): Uint8Array;
+/**
+ * Decodes unified pubKeys back to individual X25519 and Ed25519 keys
+ */
+export declare function decodeUnifiedPubKeys(pubKeys: Uint8Array): {
+    version: number;
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+} | null;
+export interface HandshakePayload {
+    unifiedPubKeys: Uint8Array;
+    ephemeralPubKey: Uint8Array;
+    plaintextPayload: string;
+}
+export interface HandshakeResponseContent {
+    unifiedPubKeys: Uint8Array;
+    ephemeralPubKey: Uint8Array;
+    note?: string;
+    identityProof: IdentityProof;
+    topicInfo?: TopicInfoWire;
+}
+export declare function encodeHandshakePayload(payload: HandshakePayload): Uint8Array;
+export declare function decodeHandshakePayload(encoded: Uint8Array): HandshakePayload;
+export declare function encodeHandshakeResponseContent(content: HandshakeResponseContent): Uint8Array;
+export declare function decodeHandshakeResponseContent(encoded: Uint8Array): HandshakeResponseContent;
+/**
+ * Creates HandshakePayload from separate identity keys
+ */
+export declare function createHandshakePayload(identityPubKey: Uint8Array, signingPubKey: Uint8Array, ephemeralPubKey: Uint8Array, plaintextPayload: string): HandshakePayload;
+/**
+ * Creates HandshakeResponseContent from separate identity keys
+ */
+export declare function createHandshakeResponseContent(identityPubKey: Uint8Array, signingPubKey: Uint8Array, ephemeralPubKey: Uint8Array, note?: string, identityProof?: IdentityProof, topicInfo?: TopicInfoWire): HandshakeResponseContent;
+/**
+ * Extracts individual keys from HandshakePayload
+ */
+export declare function extractKeysFromHandshakePayload(payload: HandshakePayload): {
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+    ephemeralPubKey: Uint8Array;
+} | null;
+/**
+ * Extracts individual keys from HandshakeResponseContent
+ */
+export declare function extractKeysFromHandshakeResponse(content: HandshakeResponseContent): {
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+    ephemeralPubKey: Uint8Array;
+} | null;
+/**
+ * Parses unified pubKeys from HandshakeLog event
+ */
+export declare function parseHandshakeKeys(event: {
+    pubKeys: string;
+}): {
+    identityPubKey: Uint8Array;
+    signingPubKey: Uint8Array;
+} | null;
+//# sourceMappingURL=payload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../src/payload.ts"],"names":[],"mappings":"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"}