@n1xyz/nord-ts 0.0.21 → 0.1.0

package/src/nord/api/actions.ts

@@ -1,16 +1,26 @@
 import Decimal from "decimal.js";
-import * as proto from "../../gen/nord";
-import { FillMode, fillModeToProtoFillMode, KeyType, Side } from "../../types";
+import * as proto from "../../gen/nord_pb";
+import { paths, components } from "../../gen/openapi";
+import createClient from "openapi-fetch";
+
+import { create } from "@bufbuild/protobuf";
+import {
+  FillMode,
+  fillModeToProtoFillMode,
+  KeyType,
+  Side,
+  QuoteSize,
+} from "../../types";
 import {
   assert,
   BigIntValue,
   checkedFetch,
   checkPubKeyLength,
   decodeLengthDelimited,
-  encodeLengthDelimited,
   SESSION_TTL,
   toScaledU64,
 } from "../../utils";
+import { sizeDelimitedEncode } from "@bufbuild/protobuf/wire";
 
 async function sessionSign(
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
@@ -28,44 +38,77 @@ async function walletSign(
   return new Uint8Array([...message, ...signature]);
 }
 
-function makeSendHttp(
-  serverUrl: string,
-): (encoded: Uint8Array) => Promise<Uint8Array> {
-  return async (body) => {
-    // TODO: this should be changed to use openapi
-    const response = await checkedFetch(`${serverUrl}/action`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body,
-    });
-    return new Uint8Array(await response.arrayBuffer());
-  };
+// Helper to create an action with common fields
+function createAction(
+  currentTimestamp: bigint,
+  nonce: number,
+  kind: proto.Action["kind"],
+): proto.Action {
+  return create(proto.ActionSchema, {
+    currentTimestamp,
+    nonce,
+    kind,
+  });
 }
 
 async function sendAction(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+  serverUrl: string,
   makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
   action: proto.Action,
   actionErrorDesc: string,
 ): Promise<proto.Receipt> {
-  const encoded = encodeLengthDelimited(action, proto.Action);
-  const body = await makeSignedMessage(encoded);
-  const rawResp = await sendFn(body);
-  const resp: proto.Receipt = decodeLengthDelimited(rawResp, proto.Receipt);
+  const body = await prepareAction(action, makeSignedMessage);
+  // NOTE: restructure and reuse client as it is in Nord.ts
+  const client = createClient<paths>({ baseUrl: serverUrl });
+  const response = await client.POST("/action", {
+    params: {
+      header: {
+        "content-type": "application/octet-stream",
+      },
+    },
+    body: body,
+  });
+
+  if (response.error) {
+    throw new Error(`Failed to ${actionErrorDesc}, HTTP status ${response}`);
+  }
+
+  const rawResp = new Uint8Array(await response.response.arrayBuffer());
 
-  if (resp.kind?.$case === "err") {
+  const resp: proto.Receipt = decodeLengthDelimited(
+    rawResp,
+    proto.ReceiptSchema,
+  );
+
+  if (resp.kind?.case === "err") {
     throw new Error(
-      `Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`,
+      `Could not ${actionErrorDesc}, reason: ${proto.Error[resp.kind.value]}`,
     );
   }
 
   return resp;
 }
 
-async function createSessionImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+// Given action and signature function, prepare the signed message to send to server as `body`.
+// `makeSignedMessage` must include the original message and signature.
+export async function prepareAction(
+  action: proto.Action,
+  makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
+) {
+  const encoded = sizeDelimitedEncode(proto.ActionSchema, action);
+  // NOTE(agent): keep in sync with MAX_HTTP_REQUEST_BODY_SIZE in rust code
+  const MAX_HTTP_REQUEST_BODY_SIZE = 1024;
+  if (encoded.byteLength > MAX_HTTP_REQUEST_BODY_SIZE) {
+    throw new Error(
+      `Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_HTTP_REQUEST_BODY_SIZE} bytes).`,
+    );
+  }
+  const body = await makeSignedMessage(encoded);
+  return body;
+}
+
+export async function createSession(
+  serverUrl: string,
   walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
@@ -75,7 +118,7 @@ async function createSessionImpl(
     // If not specified, set to current moment plus default session TTL
     expiryTimestamp?: bigint;
   },
-): Promise<bigint> {
+): Promise<{ actionId: bigint; sessionId: bigint }> {
   checkPubKeyLength(KeyType.Ed25519, params.userPubkey.length);
   checkPubKeyLength(KeyType.Ed25519, params.sessionPubkey.length);
 
@@ -91,102 +134,60 @@ async function createSessionImpl(
     expiry = currentTimestamp + SESSION_TTL;
   }
 
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce,
-    kind: {
-      $case: "createSession",
-      value: {
-        userPubkey: params.userPubkey,
-        blstPubkey: params.sessionPubkey,
-        expiryTimestamp: expiry,
-      },
-    },
-  };
+  const action = createAction(currentTimestamp, nonce, {
+    case: "createSession",
+    value: create(proto.Action_CreateSessionSchema, {
+      userPubkey: params.userPubkey,
+      blstPubkey: params.sessionPubkey,
+      expiryTimestamp: expiry,
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => walletSign(walletSignFn, m),
     action,
     "create a new session",
   );
 
-  if (resp.kind?.$case === "createSessionResult") {
-    return resp.kind.value.sessionId;
+  if (resp.kind?.case === "createSessionResult") {
+    return {
+      actionId: resp.actionId,
+      sessionId: resp.kind.value.sessionId,
+    };
   } else {
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
   }
 }
 
-export async function createSession(
+export async function revokeSession(
   serverUrl: string,
   walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
-  params: {
-    userPubkey: Uint8Array;
-    sessionPubkey: Uint8Array;
-    // If not specified, set to current moment plus default session TTL
-    expiryTimestamp?: bigint;
-  },
-): Promise<bigint> {
-  return createSessionImpl(
-    makeSendHttp(serverUrl),
-    walletSignFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
-}
-
-async function revokeSessionImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
   params: {
     sessionId: BigIntValue;
   },
-): Promise<void> {
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce,
-    kind: {
-      $case: "revokeSession",
-      value: {
-        sessionId: BigInt(params.sessionId),
-      },
-    },
-  };
+): Promise<{ actionId: bigint }> {
+  const action = createAction(currentTimestamp, nonce, {
+    case: "revokeSession",
+    value: create(proto.Action_RevokeSessionSchema, {
+      sessionId: BigInt(params.sessionId),
+    }),
+  });
 
-  await sendAction(
-    sendFn,
+  const resp = await sendAction(
+    serverUrl,
     (m) => walletSign(walletSignFn, m),
     action,
-    "create a new session",
+    "revoke session",
   );
-}
 
-export async function revokeSession(
-  serverUrl: string,
-  walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
-  params: {
-    sessionId: BigIntValue;
-  },
-): Promise<void> {
-  return revokeSessionImpl(
-    makeSendHttp(serverUrl),
-    walletSignFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
+  return { actionId: resp.actionId };
 }
 
-async function withdrawImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+export async function withdraw(
+  serverUrl: string,
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
@@ -203,63 +204,37 @@ async function withdrawImpl(
     throw new Error("Withdraw amount must be positive");
   }
 
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce,
-    kind: {
-      $case: "withdraw",
-      value: {
-        sessionId: BigInt(params.sessionId),
-        tokenId: params.tokenId,
-        amount,
-      },
-    },
-  };
+  const action = createAction(currentTimestamp, nonce, {
+    case: "withdraw",
+    value: create(proto.Action_WithdrawSchema, {
+      sessionId: BigInt(params.sessionId),
+      tokenId: params.tokenId,
+      amount,
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => sessionSign(signFn, m),
     action,
     "withdraw",
   );
 
-  if (resp.kind?.$case === "withdrawResult") {
+  if (resp.kind?.case === "withdrawResult") {
     return { actionId: resp.actionId, ...resp.kind.value };
   } else {
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
   }
 }
 
-export async function withdraw(
+export async function placeOrder(
   serverUrl: string,
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
-  params: {
-    sizeDecimals: number;
-    sessionId: BigIntValue;
-    tokenId: number;
-    amount: number;
-  },
-): Promise<{ actionId: bigint } & proto.Receipt_WithdrawResult> {
-  return withdrawImpl(
-    makeSendHttp(serverUrl),
-    signFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
-}
-
-async function placeOrderImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  signFn: (message: Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
   params: {
     sessionId: BigIntValue;
     senderId?: number;
-    liquidateeId?: number;
     sizeDecimals: number;
     priceDecimals: number;
     marketId: number;
@@ -269,154 +244,120 @@ async function placeOrderImpl(
     // NOTE: if `size` equals 1.0, it will sell whole unit, for example 1.0 BTC
     size?: Decimal.Value;
     price?: Decimal.Value;
-    quoteSizeSize?: Decimal.Value;
-    quoteSizePrice?: Decimal.Value;
+    quoteSize?: QuoteSize;
+    liquidateeId?: number;
     clientOrderId?: BigIntValue;
   },
-): Promise<bigint | undefined> {
+): Promise<{
+  actionId: bigint;
+  orderId?: bigint;
+  fills: proto.Receipt_Trade[];
+}> {
   const price = toScaledU64(params.price ?? 0, params.priceDecimals);
   const size = toScaledU64(params.size ?? 0, params.sizeDecimals);
-  const quoteSize = toScaledU64(params.quoteSizeSize ?? 0, params.sizeDecimals);
-  const quotePrice = toScaledU64(
-    params.quoteSizePrice ?? 0,
-    params.priceDecimals,
+
+  const scaledQuote = params.quoteSize
+    ? params.quoteSize.toScaledU64(params.priceDecimals, params.sizeDecimals)
+    : undefined;
+
+  assert(
+    price > 0n || size > 0n || scaledQuote !== undefined,
+    "OrderLimit must include at least one of: size, price, or quoteSize",
   );
 
-  // Compose action object
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce,
-    kind: {
-      $case: "placeOrder",
-      value: {
-        sessionId: BigInt(params.sessionId),
-        senderAccountId: params.senderId,
-        marketId: params.marketId,
-        side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
-        fillMode: fillModeToProtoFillMode(params.fillMode),
-        isReduceOnly: params.isReduceOnly,
-        price,
-        size,
-        quoteSize: { size: quoteSize, price: quotePrice },
-        clientOrderId:
-          params.clientOrderId === undefined
-            ? undefined
-            : BigInt(params.clientOrderId),
-        delegatorAccountId: params.liquidateeId,
-      },
-    },
-  };
+  const action = createAction(currentTimestamp, nonce, {
+    case: "placeOrder",
+    value: create(proto.Action_PlaceOrderSchema, {
+      sessionId: BigInt(params.sessionId),
+      senderAccountId: params.senderId,
+      marketId: params.marketId,
+      side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+      fillMode: fillModeToProtoFillMode(params.fillMode),
+      isReduceOnly: params.isReduceOnly,
+      price,
+      size,
+      quoteSize:
+        scaledQuote === undefined
+          ? undefined
+          : create(proto.QuoteSizeSchema, {
+              size: scaledQuote.size,
+              price: scaledQuote.price,
+            }),
+      clientOrderId:
+        params.clientOrderId === undefined
+          ? undefined
+          : BigInt(params.clientOrderId),
+      delegatorAccountId: params.liquidateeId,
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "place the order",
+    "place order",
   );
 
-  if (resp.kind?.$case === "placeOrderResult") {
-    return resp.kind.value.posted?.orderId;
+  if (resp.kind?.case === "placeOrderResult") {
+    return {
+      actionId: resp.actionId,
+      orderId: resp.kind.value.posted?.orderId,
+      fills: resp.kind.value.fills,
+    };
   } else {
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
   }
 }
 
-export async function placeOrder(
+export async function cancelOrder(
   serverUrl: string,
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
-  params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    sizeDecimals: number;
-    priceDecimals: number;
-    marketId: number;
-    side: Side;
-    fillMode: FillMode;
-    isReduceOnly: boolean;
-    size?: Decimal.Value;
-    price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
-    liquidateeId?: number;
-    clientOrderId?: BigIntValue;
-  },
-): Promise<bigint | undefined> {
-  return placeOrderImpl(
-    makeSendHttp(serverUrl),
-    signFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
-}
-
-async function cancelOrderImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  signFn: (message: Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
   params: {
     sessionId: BigIntValue;
     senderId?: number;
     orderId: BigIntValue;
     liquidateeId?: number;
   },
-): Promise<bigint> {
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce: nonce,
-    kind: {
-      $case: "cancelOrderById",
-      value: {
-        orderId: BigInt(params.orderId),
-        sessionId: BigInt(params.sessionId),
-        senderAccountId: params.senderId,
-        delegatorAccountId: params.liquidateeId,
-      },
-    },
-  };
+): Promise<{
+  actionId: bigint;
+  orderId: bigint;
+  accountId: number;
+}> {
+  const action = createAction(currentTimestamp, nonce, {
+    case: "cancelOrderById",
+    value: create(proto.Action_CancelOrderByIdSchema, {
+      orderId: BigInt(params.orderId),
+      sessionId: BigInt(params.sessionId),
+      senderAccountId: params.senderId,
+      delegatorAccountId: params.liquidateeId,
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "cancel the order",
+    "cancel order",
   );
 
-  if (resp.kind?.$case === "cancelOrderResult") {
-    return resp.kind.value.orderId;
+  if (resp.kind?.case === "cancelOrderResult") {
+    return {
+      actionId: resp.actionId,
+      orderId: resp.kind.value.orderId,
+      accountId: resp.kind.value.accountId,
+    };
   } else {
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
   }
 }
 
-export async function cancelOrder(
+export async function transfer(
   serverUrl: string,
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
-  params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    orderId: BigIntValue;
-    liquidateeId?: number;
-  },
-): Promise<bigint> {
-  return cancelOrderImpl(
-    makeSendHttp(serverUrl),
-    signFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
-}
-
-async function transferImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
-  signFn: (message: Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
   params: {
     sessionId: BigIntValue;
     fromAccountId: number;
@@ -425,63 +366,46 @@ async function transferImpl(
     tokenDecimals: number;
     amount: Decimal.Value;
   },
-): Promise<number | undefined> {
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce: nonce,
-    kind: {
-      $case: "transfer",
-      value: {
-        sessionId: BigInt(params.sessionId),
-        fromAccountId: params.fromAccountId,
-        toAccountId: params.toAccountId,
-        tokenId: params.tokenId,
-        amount: toScaledU64(params.amount ?? 0, params.tokenDecimals),
-      },
-    },
-  };
+): Promise<{
+  actionId: bigint;
+  fromAccountId: number;
+  toAccountId?: number;
+  tokenId: number;
+  amount: bigint;
+  accountCreated: boolean;
+}> {
+  const action = createAction(currentTimestamp, nonce, {
+    case: "transfer",
+    value: create(proto.Action_TransferSchema, {
+      sessionId: BigInt(params.sessionId),
+      fromAccountId: params.fromAccountId,
+      toAccountId: params.toAccountId,
+      tokenId: params.tokenId,
+      amount: toScaledU64(params.amount ?? 0, params.tokenDecimals),
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => sessionSign(signFn, m),
     action,
-    "transfer asset to other account",
+    "transfer",
   );
 
-  if (resp.kind?.$case === "transferred") {
-    if (resp.kind.value.accountCreated) {
-      return resp.kind.value.toUserAccount;
-    } else {
-      return undefined;
-    }
+  if (resp.kind?.case === "transferred") {
+    return {
+      actionId: resp.actionId,
+      fromAccountId: resp.kind.value.fromAccountId,
+      toAccountId: resp.kind.value.toUserAccount,
+      tokenId: resp.kind.value.tokenId,
+      amount: resp.kind.value.amount,
+      accountCreated: resp.kind.value.accountCreated,
+    };
   } else {
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
   }
 }
 
-export async function transfer(
-  serverUrl: string,
-  signFn: (message: Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
-  params: {
-    sessionId: BigIntValue;
-    fromAccountId: number;
-    toAccountId?: number;
-    tokenId: number;
-    tokenDecimals: number;
-    amount: Decimal.Value;
-  },
-): Promise<number | undefined> {
-  return transferImpl(
-    makeSendHttp(serverUrl),
-    signFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
-}
-
 export type AtomicSubaction =
   | {
       kind: "place";
@@ -496,8 +420,7 @@ export type AtomicSubaction =
       // at least one of the three has to be specified; 0 treated as "not set"
       size?: Decimal.Value;
       price?: Decimal.Value;
-      quoteSizeSize?: Decimal.Value;
-      quoteSizePrice?: Decimal.Value;
+      quoteSize?: QuoteSize;
       clientOrderId?: BigIntValue;
     }
   | {
@@ -505,8 +428,8 @@ export type AtomicSubaction =
       orderId: BigIntValue;
     };
 
-async function atomicImpl(
-  sendFn: (encoded: Uint8Array) => Promise<Uint8Array>,
+export async function atomic(
+  serverUrl: string,
   signFn: (message: Uint8Array) => Promise<Uint8Array>,
   currentTimestamp: bigint,
   nonce: number,
@@ -515,7 +438,10 @@ async function atomicImpl(
     accountId?: number;
     actions: AtomicSubaction[];
   },
-): Promise<proto.Receipt_AtomicResult> {
+): Promise<{
+  actionId: bigint;
+  results: proto.Receipt_AtomicSubactionResultKind[];
+}> {
   assert(
     params.actions.length > 0 && params.actions.length <= 4,
     "Atomic action must contain between 1 and 4 sub-actions",
@@ -525,89 +451,72 @@ async function atomicImpl(
     if (a.kind === "place") {
       const price = toScaledU64(a.price ?? 0, a.priceDecimals);
       const size = toScaledU64(a.size ?? 0, a.sizeDecimals);
-      const quoteSizeSize = toScaledU64(a.quoteSizeSize ?? 0, a.sizeDecimals);
-      const quoteSizePrice = toScaledU64(
-        a.quoteSizePrice ?? 0,
-        a.priceDecimals,
+      const scaledQuote = a.quoteSize
+        ? a.quoteSize.toScaledU64(a.priceDecimals, a.sizeDecimals)
+        : undefined;
+
+      // Require at least one limit to be set (non-zero size, non-zero price, or quoteSize)
+      assert(
+        price > 0n || size > 0n || scaledQuote !== undefined,
+        "OrderLimit must include at least one of: size, price, or quoteSize",
       );
-      const tradeOrPlace: proto.TradeOrPlace = {
-        marketId: a.marketId,
-        orderType: {
-          side: a.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
-          fillMode: fillModeToProtoFillMode(a.fillMode),
-          isReduceOnly: a.isReduceOnly,
-        },
-        limit: {
-          price,
-          size,
-          quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
+
+      const tradeOrPlace: proto.TradeOrPlace = create(
+        proto.TradeOrPlaceSchema,
+        {
+          marketId: a.marketId,
+          orderType: create(proto.OrderTypeSchema, {
+            side: a.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+            fillMode: fillModeToProtoFillMode(a.fillMode),
+            isReduceOnly: a.isReduceOnly,
+          }),
+          limit: create(proto.OrderLimitSchema, {
+            price,
+            size,
+            quoteSize:
+              scaledQuote === undefined
+                ? undefined
+                : create(proto.QuoteSizeSchema, {
+                    size: scaledQuote.size,
+                    price: scaledQuote.price,
+                  }),
+          }),
+          clientOrderId:
+            a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
         },
-        clientOrderId:
-          a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
-      };
-      return {
-        inner: { $case: "tradeOrPlace", value: tradeOrPlace },
-      } as proto.AtomicSubactionKind;
+      );
+      return create(proto.AtomicSubactionKindSchema, {
+        inner: { case: "tradeOrPlace", value: tradeOrPlace },
+      });
     }
-    return {
-      inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
-    } as proto.AtomicSubactionKind;
+    return create(proto.AtomicSubactionKindSchema, {
+      inner: {
+        case: "cancelOrder",
+        value: create(proto.CancelOrderSchema, { orderId: BigInt(a.orderId) }),
+      },
+    });
   });
 
-  const action: proto.Action = {
-    currentTimestamp,
-    nonce,
-    kind: {
-      $case: "atomic",
-      value: {
-        sessionId: BigInt(params.sessionId),
-        accountId: params.accountId, // optional
-        actions: subactions,
-      },
-    },
-  };
+  const action = createAction(currentTimestamp, nonce, {
+    case: "atomic",
+    value: create(proto.AtomicSchema, {
+      sessionId: BigInt(params.sessionId),
+      accountId: params.accountId, // optional
+      actions: subactions,
+    }),
+  });
 
   const resp = await sendAction(
-    sendFn,
+    serverUrl,
     (m) => sessionSign(signFn, m),
     action,
     "execute atomic action",
   );
-  if (resp.kind?.$case === "atomic") {
-    return resp.kind.value;
+  if (resp.kind?.case === "atomic") {
+    return {
+      actionId: resp.actionId,
+      results: resp.kind.value.results,
+    };
   }
-  throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
-}
-
-export async function atomic(
-  serverUrl: string,
-  signFn: (message: Uint8Array) => Promise<Uint8Array>,
-  currentTimestamp: bigint,
-  nonce: number,
-  params: {
-    sessionId: BigIntValue;
-    accountId?: number;
-    actions: AtomicSubaction[];
-  },
-): Promise<proto.Receipt_AtomicResult> {
-  return atomicImpl(
-    makeSendHttp(serverUrl),
-    signFn,
-    currentTimestamp,
-    nonce,
-    params,
-  );
+  throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
 }
-
-/**
- * For testing purposes
- */
-export const _private = {
-  createSessionImpl,
-  revokeSessionImpl,
-  withdrawImpl,
-  placeOrderImpl,
-  cancelOrderImpl,
-  transferImpl,
-  atomicImpl,
-};