@pomade/core 0.0.11 → 0.1.0-pre.1

package/dist/client.d.ts

@@ -1,8 +1,7 @@
-import { Maybe } from "@welshman/lib";
-import type { SignedEvent, StampedEvent } from "@welshman/util";
+import type { StampedEvent, SignedEvent } from "@welshman/util";
 import type { GroupPackage } from "@frostr/bifrost";
-import { RPC, WithEvent } from "./rpc.js";
-import { LoginOptions, LoginResult, RecoveryOptions, RecoveryResult, RecoverySetupResult, RegisterResult, SessionDeleteResult, SessionListResult, SignResult } from "./message.js";
+import { RPC } from "./rpc.js";
+import { Message, LoginStartResponse, RecoveryStartResponse } from "./message.js";
 export type ClientOptions = {
     group: GroupPackage;
     secret: string;
@@ -11,7 +10,7 @@ export type ClientOptions = {
 export type ClientOptionsResult<T> = {
     ok: boolean;
     options: [string, string[]][];
-    messages: Maybe<T>[];
+    messages: Message<T>[];
     clientSecret: string;
 };
 export declare class Client {
@@ -20,13 +19,15 @@ export declare class Client {
     group: GroupPackage;
     userPubkey: string;
     constructor(options: ClientOptions);
-    stop(): void;
     getPubkey(): Promise<string>;
-    static _buildOptions<T extends WithEvent<LoginOptions | RecoveryOptions>>(clientSecret: string, messages: Maybe<T>[], threshold: "total" | "threshold"): ClientOptionsResult<T>;
+    static _buildOptions<T extends LoginStartResponse | RecoveryStartResponse>(clientSecret: string, messages: Message<T>[], threshold: "total" | "threshold"): ClientOptionsResult<T>;
     static _getKnownPeers(): string[];
     static register(threshold: number, n: number, userSecret: string, recovery?: boolean): Promise<{
         ok: boolean;
-        messages: Maybe<RegisterResult>[];
+        messages: (Message<{
+            ok: boolean;
+            message: string;
+        }> | undefined)[];
         clientOptions: {
             peers: string[];
             group: GroupPackage;
@@ -35,43 +36,164 @@ export declare class Client {
     }>;
     setupRecovery(email: string, password: string): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<RecoverySetupResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+        }>[];
     }>;
     static requestChallenge(email: string, peers?: string[]): Promise<{
         ok: boolean;
         peersByPrefix: Map<string, string>;
     }>;
-    static loginWithPassword(email: string, password: string): Promise<ClientOptionsResult<WithEvent<LoginOptions>>>;
-    static loginWithChallenge(email: string, peersByPrefix: Map<string, string>, otps: string[]): Promise<ClientOptionsResult<WithEvent<LoginOptions>>>;
+    static loginWithPassword(email: string, password: string): Promise<ClientOptionsResult<{
+        ok: boolean;
+        message: string;
+        items?: {
+            pubkey: string;
+            client: string;
+            created_at: number;
+            last_activity: number;
+            threshold: number;
+            total: number;
+            idx: number;
+            email?: string | undefined;
+        }[] | undefined;
+    }>>;
+    static loginWithChallenge(email: string, peersByPrefix: Map<string, string>, otps: string[]): Promise<ClientOptionsResult<{
+        ok: boolean;
+        message: string;
+        items?: {
+            pubkey: string;
+            client: string;
+            created_at: number;
+            last_activity: number;
+            threshold: number;
+            total: number;
+            idx: number;
+            email?: string | undefined;
+        }[] | undefined;
+    }>>;
     static selectLogin(clientSecret: string, client: string, peers: string[]): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<LoginResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+            group?: {
+                commits: {
+                    idx: number;
+                    pubkey: string;
+                    hidden_pn: string;
+                    binder_pn: string;
+                }[];
+                group_pk: string;
+                threshold: number;
+            } | undefined;
+        }>[];
         clientOptions: ClientOptions | undefined;
     }>;
-    static recoverWithPassword(email: string, password: string): Promise<ClientOptionsResult<WithEvent<RecoveryOptions>>>;
-    static recoverWithChallenge(email: string, peersByPrefix: Map<string, string>, otps: string[]): Promise<ClientOptionsResult<WithEvent<RecoveryOptions>>>;
+    static recoverWithPassword(email: string, password: string): Promise<ClientOptionsResult<{
+        ok: boolean;
+        message: string;
+        items?: {
+            pubkey: string;
+            client: string;
+            created_at: number;
+            last_activity: number;
+            threshold: number;
+            total: number;
+            idx: number;
+            email?: string | undefined;
+        }[] | undefined;
+    }>>;
+    static recoverWithChallenge(email: string, peersByPrefix: Map<string, string>, otps: string[]): Promise<ClientOptionsResult<{
+        ok: boolean;
+        message: string;
+        items?: {
+            pubkey: string;
+            client: string;
+            created_at: number;
+            last_activity: number;
+            threshold: number;
+            total: number;
+            idx: number;
+            email?: string | undefined;
+        }[] | undefined;
+    }>>;
     static selectRecovery(clientSecret: string, client: string, peers: string[]): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<RecoveryResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+            share?: {
+                idx: number;
+                binder_sn: string;
+                hidden_sn: string;
+                seckey: string;
+            } | undefined;
+            group?: {
+                commits: {
+                    idx: number;
+                    pubkey: string;
+                    hidden_pn: string;
+                    binder_pn: string;
+                }[];
+                group_pk: string;
+                threshold: number;
+            } | undefined;
+        }>[];
         userSecret: string | undefined;
     }>;
     sign(stampedEvent: StampedEvent): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<SignResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+            result?: {
+                idx: number;
+                psigs: [string, string][];
+                pubkey: string;
+                sid: string;
+            } | undefined;
+        }>[];
         event: SignedEvent;
     } | {
         ok: boolean;
-        messages: Maybe<WithEvent<SignResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+            result?: {
+                idx: number;
+                psigs: [string, string][];
+                pubkey: string;
+                sid: string;
+            } | undefined;
+        }>[];
         event?: undefined;
     }>;
     getConversationKey(ecdh_pk: string): Promise<string | undefined>;
     listSessions(): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<SessionListResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+            items: {
+                pubkey: string;
+                client: string;
+                created_at: number;
+                last_activity: number;
+                threshold: number;
+                total: number;
+                idx: number;
+                email?: string | undefined;
+            }[];
+        }>[];
     }>;
     deleteSession(client: string, peers: string[]): Promise<{
         ok: boolean;
-        messages: Maybe<WithEvent<SessionDeleteResult>>[];
+        messages: Message<{
+            ok: boolean;
+            message: string;
+        }>[];
     }>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAaN,MAAM,eAAe,CAAA;AAKtB,OAAO,KAAK,EAAC,WAAW,EAAE,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAC,YAAY,EAAc,MAAM,iBAAiB,CAAA;AAG9D,OAAO,EAAC,GAAG,EAAE,SAAS,EAAC,MAAM,UAAU,CAAA;AACvC,OAAO,EAsBL,YAAY,EACZ,WAAW,EACX,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,UAAU,EACX,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,YAAY,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IACnC,EAAE,EAAE,OAAO,CAAA;IACX,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAA;IAC7B,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,qBAAa,MAAM;IACjB,GAAG,EAAE,GAAG,CAAA;IACR,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,EAAE,YAAY,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;gBAEN,OAAO,EAAE,aAAa;IAOlC,IAAI;IAIJ,SAAS;IAIT,MAAM,CAAC,aAAa,CAAC,CAAC,SAAS,SAAS,CAAC,YAAY,GAAG,eAAe,CAAC,EACtE,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,EACpB,SAAS,EAAE,OAAO,GAAG,WAAW,GAC/B,mBAAmB,CAAC,CAAC,CAAC;IA0CzB,MAAM,CAAC,cAAc;WAWR,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,UAAO;;;;;;;;;IAyDjF,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;WAqBtC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,WAA0B;;;;WA2B/D,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;WA0BjD,kBAAkB,CAC7B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,IAAI,EAAE,MAAM,EAAE;WA8BH,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;WA2BjE,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;WA0BnD,oBAAoB,CAC/B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,IAAI,EAAE,MAAM,EAAE;WA8BH,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;IAyB3E,IAAI,CAAC,YAAY,EAAE,YAAY;;;eAgCuB,WAAW;;;;;;IAOjE,kBAAkB,CAAC,OAAO,EAAE,MAAM;IA+BlC,YAAY;;;;IAqBZ,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;CAoBpD"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAC,YAAY,EAAE,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAC,GAAG,EAAC,MAAM,UAAU,CAAA;AAE5B,OAAO,EACL,OAAO,EAEP,kBAAkB,EAClB,qBAAqB,EAStB,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,YAAY,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IACnC,EAAE,EAAE,OAAO,CAAA;IACX,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAA;IAC7B,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,qBAAa,MAAM;IACjB,GAAG,EAAE,GAAG,CAAA;IACR,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,EAAE,YAAY,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;gBAEN,OAAO,EAAE,aAAa;IAOlC,SAAS;IAIT,MAAM,CAAC,aAAa,CAAC,CAAC,SAAS,kBAAkB,GAAG,qBAAqB,EACvE,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EACtB,SAAS,EAAE,OAAO,GAAG,WAAW,GAC/B,mBAAmB,CAAC,CAAC,CAAC;IA4CzB,MAAM,CAAC,cAAc;WASR,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,UAAO;;;;;;;;;;;;IAkDjF,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;WAYtC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,WAA0B;;;;WAuB/D,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;WAiBjD,kBAAkB,CAC7B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,IAAI,EAAE,MAAM,EAAE;;;;;;;;;;;;;;WAuBH,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;WAcjE,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;WAiBnD,oBAAoB,CAC/B,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,IAAI,EAAE,MAAM,EAAE;;;;;;;;;;;;;;WAuBH,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;IAc3E,IAAI,CAAC,YAAY,EAAE,YAAY;;;;;;;;;;;;eAwBuB,WAAW;;;;;;;;;;;;;;;IAOjE,kBAAkB,CAAC,OAAO,EAAE,MAAM;IAyBlC,YAAY;;;;;;;;;;;;;;;;;IAYZ,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;;;CASpD"}

package/dist/client.js

@@ -1,13 +1,12 @@
-import { tryCatch, groupBy, removeUndefined, shuffle, randomId, sortBy, first, last, isDefined, identity, sample, textEncoder, } from "@welshman/lib";
+import { tryCatch, groupBy, removeUndefined, shuffle, randomId, sortBy, first, last, isDefined, sample, textEncoder, } from "@welshman/lib";
 import { extract } from "@noble/hashes/hkdf.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils.js";
-import { prep, makeSecret, makeHttpAuth } from "@welshman/util";
+import { prep, makeSecret } from "@welshman/util";
 import { Lib } from "@frostr/bifrost";
-import { Method } from "./schema.js";
 import { context, hashEmail, hashPassword } from "./util.js";
 import { RPC } from "./rpc.js";
-import { isEcdhResult, isLoginOptions, isLoginResult, isRecoveryOptions, isRecoveryResult, isRecoverySetupResult, isRegisterResult, isSessionDeleteResult, isSessionListResult, isSignResult, makeChallengeRequest, makeEcdhRequest, makeLoginStart, makeLoginSelect, makeRecoveryStart, makeRecoverySelect, makeRecoverySetup, makeRegisterRequest, makeSessionDelete, makeSessionList, makeSignRequest, } from "./message.js";
+import { PomadeSigner } from "./pomade-signer.js";
 export class Client {
     rpc;
     peers;
@@ -19,17 +18,14 @@ export class Client {
         this.group = options.group;
         this.userPubkey = this.group.group_pk.slice(2);
     }
-    stop() {
-        this.rpc.stop();
-    }
     getPubkey() {
         return this.rpc.signer.getPubkey();
     }
     static _buildOptions(clientSecret, messages, threshold) {
         // Extract all items with their metadata
-        const items = messages.flatMap(m => m?.payload.items?.map(item => ({
+        const items = messages.flatMap(m => m.res?.items?.map(item => ({
             client: item.client,
-            peer: m.event.pubkey,
+            url: m.url,
             idx: item.idx,
             total: item.total,
             threshold: item.threshold,
@@ -49,24 +45,23 @@ export class Client {
             if (!hasAllIndices)
                 continue;
             // Sort by idx and map to peers
-            const peers = sortBy(item => item.idx, clientItems).map(item => item.peer);
+            const peers = sortBy(item => item.idx, clientItems).map(item => item.url);
             options.push([client, peers]);
         }
-        const ok = messages.some(m => m?.payload.ok) && options.length > 0;
+        const ok = messages.some(m => m.res?.ok) && options.length > 0;
         return { ok, options, messages, clientSecret };
     }
     static _getKnownPeers() {
-        if (context.signerPubkeys.length === 0) {
-            console.log("[pomade]: You can configure available signer pubkeys using setSignerPubkeys");
-            throw new Error("No signer pubkeys available");
+        if (context.signerUrls.length === 0) {
+            console.log("[pomade]: You can configure available signer URLs using setSignerUrls");
+            throw new Error("No signer URLs available");
         }
-        return context.signerPubkeys;
+        return context.signerUrls;
     }
-    // Register
     static async register(threshold, n, userSecret, recovery = true) {
-        if (context.signerPubkeys.length < n) {
-            console.log("[pomade]: You can configure available signer pubkeys using setSignerPubkeys");
-            throw new Error("Not enough signer pubkeys available");
+        if (context.signerUrls.length < n) {
+            console.log("[pomade]: You can configure available signer URLs using setSignerUrls");
+            throw new Error("Not enough signer URLs available");
         }
         if (threshold <= 0) {
             throw new Error("Threshold must be greater than 0");
@@ -74,27 +69,18 @@ export class Client {
         const secret = makeSecret();
         const rpc = RPC.fromSecret(secret);
         const { group, shares } = Lib.generate_dealer_pkg(threshold, n, [userSecret]);
-        const remainingSignerPubkeys = shuffle(context.signerPubkeys);
+        const remainingSignerUrls = shuffle(context.signerUrls);
         const peersByIndex = new Map();
         const messages = await Promise.all(shares.map(async (share, i) => {
-            while (remainingSignerPubkeys.length > 0) {
-                const messages = await rpc
-                    .channel(remainingSignerPubkeys.shift())
-                    .send(makeRegisterRequest({ share, group, recovery }))
-                    .receive((message, resolve) => {
-                    if (isRegisterResult(message)) {
-                        if (message.payload.ok) {
-                            peersByIndex.set(i, message.event.pubkey);
-                        }
-                        resolve(message);
-                    }
-                });
-                if (peersByIndex.has(i)) {
-                    return messages;
+            while (remainingSignerUrls.length > 0) {
+                const url = remainingSignerUrls.shift();
+                const message = await rpc.post(url, "/register", { share, group, recovery }, context.registerPow);
+                if (message.res?.ok) {
+                    peersByIndex.set(i, url);
                 }
+                return message;
             }
         }));
-        rpc.stop();
         const ok = peersByIndex.size === n;
         const peers = sortBy(first, peersByIndex).map(last);
         return {
@@ -107,158 +93,93 @@ export class Client {
             },
         };
     }
-    // Recovery setup
     async setupRecovery(email, password) {
-        const messages = await Promise.all(this.peers.map(async (peer, i) => {
-            const password_hash = await hashPassword(email, password, peer);
-            return this.rpc
-                .channel(peer)
-                .send(makeRecoverySetup({ email, password_hash }))
-                .receive((message, resolve) => {
-                if (isRecoverySetupResult(message)) {
-                    resolve(message);
-                }
-            });
+        const messages = await Promise.all(this.peers.map(async (url) => {
+            const password_hash = await hashPassword(email, password, url);
+            return this.rpc.post(url, "/recovery/setup", { email, password_hash });
         }));
-        return { ok: messages.every(m => m?.payload.ok), messages };
+        return { ok: messages.every(m => m.res?.ok), messages };
     }
-    // Challenge
     static async requestChallenge(email, peers = Client._getKnownPeers()) {
         const clientSecret = makeSecret();
         const rpc = RPC.fromSecret(clientSecret);
         const peersByPrefix = new Map();
-        const oks = await Promise.all(peers.map(async (peer, i) => {
+        const results = await Promise.all(peers.map(async (url) => {
             let prefix = randomId().slice(-2);
             while (peersByPrefix.has(prefix)) {
                 prefix = randomId().slice(-2);
             }
-            peersByPrefix.set(prefix, peer);
-            const email_hash = await hashEmail(email, peer);
-            return rpc.channel(peer).send(makeChallengeRequest({ prefix, email_hash })).ok;
+            peersByPrefix.set(prefix, url);
+            const email_hash = await hashEmail(email, url);
+            return rpc.post(url, "/challenge", { prefix, email_hash });
         }));
-        rpc.stop();
-        return { ok: oks.every(identity), peersByPrefix };
+        return { ok: results.every(r => r.res?.ok), peersByPrefix };
     }
-    // Login
     static async loginWithPassword(email, password) {
         const clientSecret = makeSecret();
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(Client._getKnownPeers().map(async (peer, i) => {
-            const email_hash = await hashEmail(email, peer);
-            const password_hash = await hashPassword(email, password, peer);
+        const messages = await Promise.all(Client._getKnownPeers().map(async (url) => {
+            const email_hash = await hashEmail(email, url);
+            const password_hash = await hashPassword(email, password, url);
             const auth = { email_hash, password_hash };
-            return rpc
-                .channel(peer)
-                .send(makeLoginStart({ auth }))
-                .receive((message, resolve) => {
-                if (isLoginOptions(message)) {
-                    resolve(message);
-                }
-            });
+            return rpc.post(url, "/login/start", { auth });
         }));
-        rpc.stop();
         return this._buildOptions(clientSecret, messages, "total");
     }
     static async loginWithChallenge(email, peersByPrefix, otps) {
         const clientSecret = makeSecret();
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(otps.map(async (otp) => {
-            const peer = peersByPrefix.get(otp.slice(0, 2));
-            if (peer) {
-                const email_hash = await hashEmail(email, peer);
+        const messages = removeUndefined(await Promise.all(otps.map(async (otp) => {
+            const url = peersByPrefix.get(otp.slice(0, 2));
+            if (url) {
+                const email_hash = await hashEmail(email, url);
                 const auth = { email_hash, otp };
-                return rpc
-                    .channel(peer)
-                    .send(makeLoginStart({ auth }))
-                    .receive((message, resolve) => {
-                    if (isLoginOptions(message)) {
-                        resolve(message);
-                    }
-                });
+                return rpc.post(url, "/login/start", { auth });
             }
-        }));
-        rpc.stop();
+        })));
         return this._buildOptions(clientSecret, messages, "total");
     }
     static async selectLogin(clientSecret, client, peers) {
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(peers.map((peer, i) => {
-            return rpc
-                .channel(peer)
-                .send(makeLoginSelect({ client }))
-                .receive((message, resolve) => {
-                if (isLoginResult(message)) {
-                    resolve(message);
-                }
-            });
-        }));
-        rpc.stop();
-        const group = messages.find(m => m?.payload.group)?.payload.group;
-        const ok = Boolean(group && messages.every(m => m?.payload.ok));
+        const messages = await Promise.all(peers.map(url => rpc.post(url, "/login/select", { client })));
+        const group = messages.find(m => m.res?.group)?.res?.group;
+        const ok = Boolean(group && messages.every(m => m.res?.ok));
         const clientOptions = ok ? { group, peers, secret: clientSecret } : undefined;
         return { ok, messages, clientOptions };
     }
-    // Recovery
     static async recoverWithPassword(email, password) {
         const clientSecret = makeSecret();
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(Client._getKnownPeers().map(async (peer, i) => {
-            const email_hash = await hashEmail(email, peer);
-            const password_hash = await hashPassword(email, password, peer);
+        const messages = await Promise.all(Client._getKnownPeers().map(async (url) => {
+            const email_hash = await hashEmail(email, url);
+            const password_hash = await hashPassword(email, password, url);
             const auth = { email_hash, password_hash };
-            return rpc
-                .channel(peer)
-                .send(makeRecoveryStart({ auth }))
-                .receive((message, resolve) => {
-                if (isRecoveryOptions(message)) {
-                    resolve(message);
-                }
-            });
+            return rpc.post(url, "/recovery/start", { auth });
         }));
-        rpc.stop();
         return this._buildOptions(clientSecret, messages, "threshold");
     }
     static async recoverWithChallenge(email, peersByPrefix, otps) {
         const clientSecret = makeSecret();
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(otps.map(async (otp) => {
-            const peer = peersByPrefix.get(otp.slice(0, 2));
-            if (peer) {
-                const email_hash = await hashEmail(email, peer);
+        const messages = removeUndefined(await Promise.all(otps.map(async (otp) => {
+            const url = peersByPrefix.get(otp.slice(0, 2));
+            if (url) {
+                const email_hash = await hashEmail(email, url);
                 const auth = { email_hash, otp };
-                return rpc
-                    .channel(peer)
-                    .send(makeRecoveryStart({ auth }))
-                    .receive((message, resolve) => {
-                    if (isRecoveryOptions(message)) {
-                        resolve(message);
-                    }
-                });
+                return rpc.post(url, "/recovery/start", { auth });
             }
-        }));
-        rpc.stop();
+        })));
         return this._buildOptions(clientSecret, messages, "threshold");
     }
     static async selectRecovery(clientSecret, client, peers) {
         const rpc = RPC.fromSecret(clientSecret);
-        const messages = await Promise.all(peers.map(peer => {
-            return rpc
-                .channel(peer)
-                .send(makeRecoverySelect({ client }))
-                .receive((message, resolve) => {
-                if (isRecoveryResult(message)) {
-                    resolve(message);
-                }
-            });
-        }));
-        rpc.stop();
-        const group = messages.find(m => m?.payload.group)?.payload.group;
-        const shares = removeUndefined(messages.map(m => m?.payload.share));
+        const messages = await Promise.all(peers.map(url => rpc.post(url, "/recovery/select", { client })));
+        const group = messages.find(m => m.res?.group)?.res?.group;
+        const shares = removeUndefined(messages.map(m => m.res?.share));
         const userSecret = tryCatch(() => Lib.recover_secret_key(group, shares));
         return { ok: Boolean(userSecret), messages, userSecret };
     }
     async sign(stampedEvent) {
-        // TODO: optimize this so that all signers are asked, but only the fastest results get used
         const { threshold, commits } = this.group;
         const event = prep(stampedEvent, this.userPubkey);
         const members = sample(threshold, commits).map(c => c.idx);
@@ -267,19 +188,12 @@ export class Client {
             throw new Error("Failed to create signing template");
         const request = Lib.create_session_pkg(this.group, template);
         const messages = await Promise.all(members.map(idx => {
-            const peer = this.peers[idx - 1];
-            return this.rpc
-                .channel(peer)
-                .send(makeSignRequest({ request }))
-                .receive((message, resolve) => {
-                if (isSignResult(message)) {
-                    resolve(message);
-                }
-            });
+            const url = this.peers[idx - 1];
+            return this.rpc.post(url, "/sign", { request });
         }));
-        if (messages.every(m => m?.payload.ok)) {
+        if (messages.every(m => m.res?.ok)) {
             const ctx = Lib.get_session_ctx(this.group, request);
-            const pkgs = messages.map(m => m.payload.result);
+            const pkgs = messages.map(m => m.res.result);
             const sig = Lib.combine_signature_pkgs(ctx, pkgs)[0]?.[2];
             if (sig) {
                 return { ok: true, messages, event: { ...event, sig } };
@@ -288,55 +202,27 @@ export class Client {
         return { ok: false, messages };
     }
     async getConversationKey(ecdh_pk) {
-        // TODO: optimize this so that all signers are asked, but only the fastest results get used
         const { threshold, commits } = this.group;
         const members = sample(threshold, commits).map(c => c.idx);
         const results = await Promise.all(members.map(idx => {
-            const peer = this.peers[idx - 1];
-            const channel = this.rpc.channel(peer);
-            return channel
-                .send(makeEcdhRequest({ idx, members, ecdh_pk }))
-                .receive((message, resolve) => {
-                if (isEcdhResult(message)) {
-                    resolve(message.payload.result);
-                }
-            });
+            const url = this.peers[idx - 1];
+            return this.rpc
+                .post(url, "/ecdh", { idx, members, ecdh_pk })
+                .then(r => r.res?.result);
         }));
         if (results.every(isDefined)) {
             return bytesToHex(extract(sha256, hexToBytes(Lib.combine_ecdh_pkgs(results).slice(2)), textEncoder.encode("nip44-v2")));
         }
     }
     async listSessions() {
-        const messages = await Promise.all(Client._getKnownPeers().map(async (peer, i) => {
-            const { event: auth } = await this.sign(await makeHttpAuth(peer, Method.SessionList));
-            if (auth) {
-                return this.rpc
-                    .channel(peer)
-                    .send(makeSessionList({ auth }))
-                    .receive((message, resolve) => {
-                    if (isSessionListResult(message)) {
-                        resolve(message);
-                    }
-                });
-            }
-        }));
-        return { ok: messages.every(m => m?.payload.ok), messages };
+        const userRpc = new RPC(new PomadeSigner(this));
+        const messages = await Promise.all(Client._getKnownPeers().map(url => userRpc.post(url, "/session/list", {})));
+        return { ok: messages.every(m => m.res?.ok), messages };
     }
     async deleteSession(client, peers) {
-        const messages = await Promise.all(peers.map(async (peer, i) => {
-            const { event: auth } = await this.sign(await makeHttpAuth(peer, Method.SessionDelete));
-            if (auth) {
-                return this.rpc
-                    .channel(peer)
-                    .send(makeSessionDelete({ client, auth }))
-                    .receive((message, resolve) => {
-                    if (isSessionDeleteResult(message)) {
-                        resolve(message);
-                    }
-                });
-            }
-        }));
-        return { ok: messages.every(m => m?.payload.ok), messages };
+        const userRpc = new RPC(new PomadeSigner(this));
+        const messages = await Promise.all(peers.map(url => userRpc.post(url, "/session/delete", { client })));
+        return { ok: messages.every(m => m.res?.ok), messages };
     }
 }
 //# sourceMappingURL=client.js.map