@invago/mixin 1.0.9 → 1.0.10

package/src/mixpay-worker.ts

@@ -0,0 +1,353 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getMixpayConfig } from "./config.js";
+import type { MixinMixpayConfig } from "./config-schema.js";
+import { createMixpayPayment, getMixpayPaymentResult, type MixpayPaymentResult } from "./mixpay-service.js";
+import {
+  createMixpayOrder,
+  findMixpayOrder,
+  getMixpayStoreSnapshot,
+  listPendingMixpayOrders,
+  listRecentMixpayOrders,
+  type MixpayOrderRecord,
+  type MixpayOrderStatus,
+  updateMixpayOrder,
+} from "./mixpay-store.js";
+import { sendTextMessage } from "./send-service.js";
+import { sleep, type SendLog } from "./shared.js";
+
+export type MixinCollectRequest = {
+  amount: string;
+  assetId?: string;
+  settlementAssetId?: string;
+  memo?: string;
+  orderId?: string;
+  expireMinutes?: number;
+};
+
+const state: {
+  started: boolean;
+  cfg: OpenClawConfig | null;
+  log: SendLog | null;
+} = {
+  started: false,
+  cfg: null,
+  log: null,
+};
+
+function getPendingPollDelayMs(cfg: OpenClawConfig): number {
+  const configured = Object.values((cfg.channels?.mixin as { accounts?: Record<string, { mixpay?: MixinMixpayConfig }> } | undefined)?.accounts ?? {})
+    .map((account) => account?.mixpay?.pollIntervalSec)
+    .filter((value): value is number => typeof value === "number" && Number.isFinite(value) && value > 0);
+  const topLevel = (cfg.channels?.mixin as { mixpay?: MixinMixpayConfig } | undefined)?.mixpay?.pollIntervalSec;
+  if (typeof topLevel === "number" && Number.isFinite(topLevel) && topLevel > 0) {
+    configured.push(topLevel);
+  }
+  return Math.max(5_000, Math.min(...(configured.length > 0 ? configured : [30])) * 1000);
+}
+
+function formatStatusLabel(status: MixpayOrderStatus): string {
+  switch (status) {
+    case "unpaid":
+      return "unpaid";
+    case "pending":
+      return "pending";
+    case "paid_less":
+      return "paid less";
+    case "success":
+      return "success";
+    case "failed":
+      return "failed";
+    case "expired":
+      return "expired";
+    default:
+      return "unknown";
+  }
+}
+
+export function formatMixpayOrderSummary(order: MixpayOrderRecord): string {
+  const lines = [
+    `MixPay order: ${order.orderId}`,
+    `Status: ${formatStatusLabel(order.status)}`,
+    `Amount: ${order.quoteAmount} ${order.quoteAssetId}`,
+  ];
+  if (order.paymentUrl) {
+    lines.push(`Pay: ${order.paymentUrl}`);
+  }
+  if (order.memo) {
+    lines.push(`Memo: ${order.memo}`);
+  }
+  if (order.expireAt) {
+    lines.push(`Expires: ${order.expireAt}`);
+  }
+  if (order.latestError) {
+    lines.push(`Latest error: ${order.latestError}`);
+  }
+  return lines.join("\n");
+}
+
+function shouldNotifyStatus(config: MixinMixpayConfig, status: MixpayOrderStatus): boolean {
+  if (status === "success" || status === "failed" || status === "expired") {
+    return true;
+  }
+  if (status === "pending") {
+    return config.notifyOnPending === true;
+  }
+  if (status === "paid_less") {
+    return config.notifyOnPaidLess !== false;
+  }
+  return false;
+}
+
+function validateMixpayResult(
+  order: MixpayOrderRecord,
+  payment: MixpayPaymentResult,
+  config: MixinMixpayConfig,
+): string | null {
+  if (config.payeeId?.trim() && payment.payeeId?.trim() && config.payeeId.trim() !== payment.payeeId.trim()) {
+    return "MixPay payeeId mismatch";
+  }
+  if (payment.quoteAssetId?.trim() && payment.quoteAssetId.trim() !== order.quoteAssetId.trim()) {
+    return "MixPay quoteAssetId mismatch";
+  }
+  if (payment.quoteAmount?.trim() && payment.quoteAmount.trim() !== order.quoteAmount.trim()) {
+    return "MixPay quoteAmount mismatch";
+  }
+  return null;
+}
+
+async function notifyOrderStatus(
+  cfg: OpenClawConfig,
+  order: MixpayOrderRecord,
+  nextStatus: MixpayOrderStatus,
+  log: SendLog,
+): Promise<void> {
+  const recipientId = order.recipientId || undefined;
+  const message = [
+    `MixPay order update: ${order.orderId}`,
+    `Status: ${formatStatusLabel(nextStatus)}`,
+    `Amount: ${order.quoteAmount} ${order.quoteAssetId}`,
+  ];
+  if (order.paymentUrl) {
+    message.push(`Pay: ${order.paymentUrl}`);
+  }
+  const result = await sendTextMessage(cfg, order.accountId, order.conversationId, recipientId, message.join("\n"), log);
+  if (!result.ok) {
+    throw new Error(result.error ?? "failed to notify MixPay order status");
+  }
+}
+
+async function pollPendingOrders(): Promise<void> {
+  const cfg = state.cfg;
+  const log = state.log;
+  if (!cfg || !log) {
+    return;
+  }
+
+  const pendingOrders = await listPendingMixpayOrders();
+  for (const order of pendingOrders) {
+    const mixpayConfig = getMixpayConfig(cfg, order.accountId);
+    if (!mixpayConfig?.enabled) {
+      continue;
+    }
+
+    try {
+      const payment = await getMixpayPaymentResult({ config: mixpayConfig, orderId: order.orderId, traceId: order.traceId });
+      const mismatch = validateMixpayResult(order, payment, mixpayConfig);
+      if (mismatch) {
+        throw new Error(mismatch);
+      }
+      const nextStatus = payment.status;
+      const updated = await updateMixpayOrder(order.orderId, (current) => ({
+        ...current,
+        paymentId: current.paymentId ?? payment.raw.id as string | undefined,
+        rawStatus: payment.rawStatus,
+        status: nextStatus,
+        lastPolledAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }));
+
+      if (!updated) {
+        continue;
+      }
+
+      if (updated.lastNotifyStatus !== nextStatus && shouldNotifyStatus(mixpayConfig, nextStatus)) {
+        await notifyOrderStatus(cfg, updated, nextStatus, log);
+        await updateMixpayOrder(order.orderId, (current) => ({
+          ...current,
+          lastNotifyStatus: nextStatus,
+          updatedAt: new Date().toISOString(),
+        }));
+      }
+    } catch (err) {
+      log.warn(`[mixin] MixPay poll failed: orderId=${order.orderId}, error=${err instanceof Error ? err.message : String(err)}`);
+      await updateMixpayOrder(order.orderId, (current) => ({
+        ...current,
+        latestError: err instanceof Error ? err.message : String(err),
+        lastPolledAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }));
+    }
+  }
+}
+
+export async function startMixpayWorker(cfg: OpenClawConfig, log: SendLog): Promise<void> {
+  state.cfg = cfg;
+  state.log = log;
+  if (state.started) {
+    return;
+  }
+  state.started = true;
+
+  void (async () => {
+    while (true) {
+      try {
+        await pollPendingOrders();
+      } catch (err) {
+        log.error("[mixin] MixPay worker loop failed", err);
+      }
+      await sleep(getPendingPollDelayMs(state.cfg ?? cfg));
+    }
+  })();
+}
+
+export async function createMixinCollectOrder(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  conversationId: string;
+  recipientId?: string;
+  creatorId: string;
+  request: MixinCollectRequest;
+}): Promise<MixpayOrderRecord> {
+  const mixpayConfig = getMixpayConfig(params.cfg, params.accountId);
+  if (!mixpayConfig?.enabled) {
+    throw new Error("MixPay is not enabled for this Mixin account");
+  }
+
+  const normalizedCreatorId = params.creatorId.trim().toLowerCase();
+  const allowedCreators = (mixpayConfig.allowedCreators ?? []).map((item) => item.trim().toLowerCase()).filter(Boolean);
+  if (allowedCreators.length > 0 && !allowedCreators.includes(normalizedCreatorId)) {
+    throw new Error("MixPay collect creation is not allowed for this sender");
+  }
+
+  const created = await createMixpayPayment({
+    config: mixpayConfig,
+    orderId: params.request.orderId,
+    quoteAmount: params.request.amount,
+    quoteAssetId: params.request.assetId?.trim() || mixpayConfig.defaultQuoteAssetId?.trim() || "",
+    settlementAssetId: params.request.settlementAssetId,
+    memo: params.request.memo,
+    expireMinutes: params.request.expireMinutes,
+  });
+
+  const quoteAssetId = params.request.assetId?.trim() || mixpayConfig.defaultQuoteAssetId?.trim();
+  if (!quoteAssetId) {
+    throw new Error("MixPay quote asset is not configured");
+  }
+
+  const record: MixpayOrderRecord = {
+    orderId: created.orderId,
+    traceId: created.traceId,
+    paymentId: created.paymentId,
+    code: created.code,
+    paymentUrl: created.paymentUrl,
+    accountId: params.accountId,
+    conversationId: params.conversationId,
+    recipientId: params.recipientId,
+    creatorId: params.creatorId,
+    quoteAssetId,
+    quoteAmount: params.request.amount,
+    settlementAssetId: params.request.settlementAssetId,
+    memo: params.request.memo,
+    status: "unpaid",
+    createdAt: created.createdAt,
+    updatedAt: created.createdAt,
+    expireAt: created.expireAt,
+  };
+
+  await createMixpayOrder(record);
+  return record;
+}
+
+export async function getMixpayOrderStatusText(orderId: string): Promise<string> {
+  const order = await findMixpayOrder(orderId);
+  if (!order) {
+    return `MixPay order not found: ${orderId}`;
+  }
+  return formatMixpayOrderSummary(order);
+}
+
+export async function refreshMixpayOrderStatus(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  orderId: string;
+}): Promise<MixpayOrderRecord | null> {
+  const order = await findMixpayOrder(params.orderId);
+  if (!order || order.accountId !== params.accountId) {
+    return order;
+  }
+
+  const mixpayConfig = getMixpayConfig(params.cfg, params.accountId);
+  if (!mixpayConfig?.enabled) {
+    return order;
+  }
+
+  try {
+    const payment = await getMixpayPaymentResult({
+      config: mixpayConfig,
+      orderId: order.orderId,
+      traceId: order.traceId,
+    });
+    const mismatch = validateMixpayResult(order, payment, mixpayConfig);
+    if (mismatch) {
+      throw new Error(mismatch);
+    }
+    return await updateMixpayOrder(order.orderId, (current) => ({
+      ...current,
+      rawStatus: payment.rawStatus,
+      status: payment.status,
+      lastPolledAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      latestError: undefined,
+    }));
+  } catch (err) {
+    return await updateMixpayOrder(order.orderId, (current) => ({
+      ...current,
+      latestError: err instanceof Error ? err.message : String(err),
+      lastPolledAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }));
+  }
+}
+
+export async function getRecentMixpayOrdersText(params: {
+  accountId: string;
+  conversationId: string;
+  limit?: number;
+}): Promise<string> {
+  const items = await listRecentMixpayOrders({
+    accountId: params.accountId,
+    conversationId: params.conversationId,
+    limit: params.limit ?? 5,
+  });
+
+  if (items.length === 0) {
+    return "No MixPay orders found for this conversation.";
+  }
+
+  return items
+    .map((item) => `${item.orderId} | ${formatStatusLabel(item.status)} | ${item.quoteAmount} ${item.quoteAssetId}`)
+    .join("\n");
+}
+
+export async function getMixpayStatusSnapshot(): Promise<{
+  pendingOrders: number;
+  storeDir: string;
+  storeFile: string;
+}> {
+  const snapshot = await getMixpayStoreSnapshot();
+  return {
+    pendingOrders: snapshot.pending,
+    storeDir: snapshot.storeDir,
+    storeFile: snapshot.storeFile,
+  };
+}

package/src/outbound-plan.ts

@@ -1,5 +1,6 @@
 import type { ReplyPayload } from "openclaw/plugin-sdk";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { createMixinCollectOrder, formatMixpayOrderSummary } from "./mixpay-worker.js";
 import { buildMixinReplyPlan, resolveMixinReplyPlan } from "./reply-format.js";
 import {
   sendAudioMessage,
@@ -9,18 +10,14 @@ import {
   sendPostMessage,
   sendTextMessage,
 } from "./send-service.js";
-
-type SendLog = {
-  info: (msg: string) => void;
-  warn: (msg: string) => void;
-  error: (msg: string, err?: unknown) => void;
-};
+import type { SendLog } from "./shared.js";
 
 export type MixinOutboundStep =
   | { kind: "text"; text: string }
   | { kind: "post"; text: string }
   | { kind: "file"; file: Parameters<typeof sendFileMessage>[4] }
   | { kind: "audio"; audio: Parameters<typeof sendAudioMessage>[4] }
+  | { kind: "collect"; collect: Parameters<typeof createMixinCollectOrder>[0]["request"] }
   | { kind: "buttons"; intro?: string; buttons: Parameters<typeof sendButtonGroupMessage>[4] }
   | { kind: "card"; card: Parameters<typeof sendCardMessage>[4] }
   | { kind: "media-url"; mediaUrl: string };
@@ -77,6 +74,10 @@ function appendReplyTextPlan(
     steps.push({ kind: "audio", audio: plan.audio });
     return;
   }
+  if (plan.kind === "collect") {
+    steps.push({ kind: "collect", collect: plan.collect });
+    return;
+  }
   if (plan.kind === "buttons") {
     steps.push({ kind: "buttons", intro: plan.intro, buttons: plan.buttons });
     return;
@@ -118,11 +119,12 @@ export async function executeMixinOutboundPlan(params: {
   accountId: string;
   conversationId: string;
   recipientId?: string;
+  creatorId?: string;
   steps: MixinOutboundStep[];
   log?: SendLog;
   sendMediaUrl?: (mediaUrl: string) => Promise<string | undefined>;
 }): Promise<string | undefined> {
-  const { cfg, accountId, conversationId, recipientId, steps, log, sendMediaUrl } = params;
+  const { cfg, accountId, conversationId, recipientId, creatorId, steps, log, sendMediaUrl } = params;
   let lastMessageId: string | undefined;
 
   for (const step of steps) {
@@ -162,6 +164,23 @@ export async function executeMixinOutboundPlan(params: {
       continue;
     }
 
+    if (step.kind === "collect") {
+      const order = await createMixinCollectOrder({
+        cfg,
+        accountId,
+        conversationId,
+        recipientId,
+        creatorId: creatorId ?? recipientId ?? conversationId,
+        request: step.collect,
+      });
+      const result = await sendTextMessage(cfg, accountId, conversationId, recipientId, formatMixpayOrderSummary(order), log);
+      if (!result.ok) {
+        throw new Error(result.error ?? "mixin outbound MixPay collect send failed");
+      }
+      lastMessageId = result.messageId ?? lastMessageId;
+      continue;
+    }
+
     if (step.kind === "buttons") {
       if (step.intro) {
         const introResult = await sendTextMessage(cfg, accountId, conversationId, recipientId, step.intro, log);

package/src/reply-format.ts

@@ -1,3 +1,4 @@
+import type { MixinCollectRequest } from "./mixpay-worker.js";
 import type { MixinAudio, MixinButton, MixinCard, MixinFile } from "./send-service.js";
 
 type LinkItem = {
@@ -10,6 +11,7 @@ export type MixinReplyPlan =
   | { kind: "post"; text: string }
   | { kind: "file"; file: MixinFile }
   | { kind: "audio"; audio: MixinAudio }
+  | { kind: "collect"; collect: MixinCollectRequest }
   | { kind: "buttons"; intro?: string; buttons: MixinButton[] }
   | { kind: "card"; card: MixinCard };
 
@@ -21,7 +23,7 @@ const MAX_BUTTONS = 6;
 const MAX_BUTTON_LABEL = 36;
 const MAX_CARD_TITLE = 36;
 const MAX_CARD_DESCRIPTION = 120;
-const TEMPLATE_REGEX = /^```mixin-(text|post|buttons|card|file|audio)\s*\n([\s\S]*?)\n```$/i;
+const TEMPLATE_REGEX = /^```mixin-(text|post|buttons|card|file|audio|collect)\s*\n([\s\S]*?)\n```$/i;
 
 function truncate(value: string, limit: number): string {
   return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 3))}...`;
@@ -170,6 +172,51 @@ function parseAudioTemplate(body: string): MixinReplyPlan | null {
   };
 }
 
+function parseCollectTemplate(body: string): MixinReplyPlan | null {
+  const parsed = parseJsonTemplate<{
+    amount?: unknown;
+    assetId?: unknown;
+    quoteAssetId?: unknown;
+    settlementAssetId?: unknown;
+    memo?: unknown;
+    orderId?: unknown;
+    expireMinutes?: unknown;
+  }>(body);
+  if (!parsed) {
+    return null;
+  }
+
+  const amount = typeof parsed.amount === "string"
+    ? normalizeWhitespace(parsed.amount)
+    : typeof parsed.amount === "number"
+      ? String(parsed.amount)
+      : "";
+  const assetId = typeof parsed.assetId === "string"
+    ? normalizeWhitespace(parsed.assetId)
+    : typeof parsed.quoteAssetId === "string"
+      ? normalizeWhitespace(parsed.quoteAssetId)
+      : "";
+  if (!amount) {
+    return null;
+  }
+
+  return {
+    kind: "collect",
+    collect: {
+      amount,
+      assetId: assetId || undefined,
+      settlementAssetId: typeof parsed.settlementAssetId === "string"
+        ? normalizeWhitespace(parsed.settlementAssetId)
+        : undefined,
+      memo: typeof parsed.memo === "string" ? normalizeWhitespace(parsed.memo) : undefined,
+      orderId: typeof parsed.orderId === "string" ? normalizeWhitespace(parsed.orderId) : undefined,
+      expireMinutes: typeof parsed.expireMinutes === "number" && Number.isFinite(parsed.expireMinutes)
+        ? parsed.expireMinutes
+        : undefined,
+    },
+  };
+}
+
 function parseExplicitTemplate(text: string): MixinReplyPlanResolution {
   const match = text.match(TEMPLATE_REGEX);
   if (!match) {
@@ -203,6 +250,10 @@ function parseExplicitTemplate(text: string): MixinReplyPlanResolution {
     return { matchedTemplate: true, plan: parseAudioTemplate(body), error: "Invalid mixin-audio template JSON" };
   }
 
+  if (templateType === "collect") {
+    return { matchedTemplate: true, plan: parseCollectTemplate(body), error: "Invalid mixin-collect template JSON" };
+  }
+
   return { matchedTemplate: true, plan: null, error: "Unknown Mixin template type" };
 }
 

package/src/runtime.ts

@@ -1,6 +1,17 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { MixinSupportedMessageCategory } from "./send-service.js";
 
 let runtime: PluginRuntime | null = null;
+const blazeSenders = new Map<string, MixinBlazeSender>();
+
+export type MixinBlazeOutboundMessage = {
+  conversationId: string;
+  messageId: string;
+  category: MixinSupportedMessageCategory;
+  dataBase64: string;
+};
+
+export type MixinBlazeSender = (message: MixinBlazeOutboundMessage) => Promise<void>;
 
 export function setMixinRuntime(next: PluginRuntime): void {
   runtime = next;
@@ -10,3 +21,18 @@ export function getMixinRuntime(): PluginRuntime {
   if (!runtime) throw new Error("Mixin runtime not initialized");
   return runtime;
 }
+
+export function setMixinBlazeSender(accountId: string, sender: MixinBlazeSender | null): void {
+  if (!accountId.trim()) {
+    return;
+  }
+  if (sender) {
+    blazeSenders.set(accountId, sender);
+    return;
+  }
+  blazeSenders.delete(accountId);
+}
+
+export function getMixinBlazeSender(accountId: string): MixinBlazeSender | null {
+  return blazeSenders.get(accountId) ?? null;
+}

package/src/send-service.ts

@@ -2,12 +2,10 @@ import crypto from "crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
 import os from "os";
 import path from "path";
-import { MixinApi } from "@mixin.dev/mixin-node-sdk";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import type { MixinAccountConfig } from "./config-schema.js";
 import { getAccountConfig } from "./config.js";
-import { buildRequestConfig } from "./proxy.js";
-import { getMixinRuntime } from "./runtime.js";
+import { getMixinBlazeSender, getMixinRuntime } from "./runtime.js";
+import { buildClient, sleep, type SendLog } from "./shared.js";
 
 const BASE_DELAY = 1000;
 const MAX_DELAY = 60_000;
@@ -15,12 +13,6 @@ const MULTIPLIER = 1.5;
 const MAX_ERROR_LENGTH = 500;
 const MAX_OUTBOX_FILE_BYTES = 10 * 1024 * 1024;
 
-type SendLog = {
-  info: (msg: string) => void;
-  error: (msg: string, err?: unknown) => void;
-  warn: (msg: string) => void;
-};
-
 export type MixinSupportedMessageCategory =
   | "PLAIN_TEXT"
   | "PLAIN_POST"
@@ -139,22 +131,6 @@ const state: {
   wakeResolver: null,
 };
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function buildClient(config: MixinAccountConfig) {
-  return MixinApi({
-    keystore: {
-      app_id: config.appId!,
-      session_id: config.sessionId!,
-      server_public_key: config.serverPublicKey!,
-      session_private_key: config.sessionPrivateKey!,
-    },
-    requestConfig: buildRequestConfig(config.proxy),
-  });
-}
-
 function guessMimeType(fileName: string): string {
   const ext = path.extname(fileName).toLowerCase();
   switch (ext) {
@@ -277,7 +253,7 @@ function normalizeEntry(entry: OutboxEntry): OutboxEntry {
   };
 }
 
-function isStructuredBody(body: string): body is string {
+function isStructuredBody(body: string): boolean {
   return body.trim().startsWith("{");
 }
 
@@ -475,6 +451,23 @@ async function attemptSend(entry: OutboxEntry): Promise<void> {
   }
 
   const dataBase64 = Buffer.from(payloadBody).toString("base64");
+  if (!entry.recipientId) {
+    const blazeSender = getMixinBlazeSender(entry.accountId);
+    if (!blazeSender) {
+      throw new Error("group send failed: blaze sender unavailable");
+    }
+    state.log.info(
+      `[mixin] attempt send: transport=blaze, jobId=${entry.jobId}, messageId=${entry.messageId}, conversation=${entry.conversationId}, recipient=none, category=${entry.category}`,
+    );
+    await blazeSender({
+      conversationId: entry.conversationId,
+      messageId: entry.messageId,
+      category: entry.category,
+      dataBase64,
+    });
+    return;
+  }
+
   const messagePayload: {
     conversation_id: string;
     message_id: string;
@@ -492,6 +485,10 @@ async function attemptSend(entry: OutboxEntry): Promise<void> {
     messagePayload.recipient_id = entry.recipientId;
   }
 
+  state.log.info(
+    `[mixin] attempt send: transport=rest, jobId=${entry.jobId}, messageId=${entry.messageId}, conversation=${entry.conversationId}, recipient=${messagePayload.recipient_id ?? "none"}, category=${entry.category}`,
+  );
+
   await client.message.sendOne(messagePayload);
 }
 

package/src/shared.ts

@@ -0,0 +1,25 @@
+import { MixinApi } from "@mixin.dev/mixin-node-sdk";
+import type { MixinAccountConfig } from "./config-schema.js";
+import { buildRequestConfig } from "./proxy.js";
+
+export type SendLog = {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string, err?: unknown) => void;
+};
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function buildClient(config: MixinAccountConfig) {
+  return MixinApi({
+    keystore: {
+      app_id: config.appId!,
+      session_id: config.sessionId!,
+      server_public_key: config.serverPublicKey!,
+      session_private_key: config.sessionPrivateKey!,
+    },
+    requestConfig: buildRequestConfig(config.proxy),
+  });
+}