@n1xyz/nord-ts 0.1.6 → 0.1.7

package/src/{nord/client → client}/NordUser.ts

@@ -4,16 +4,9 @@ import {
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
 } from "@solana/spl-token";
-import {
-  Connection,
-  PublicKey,
-  Transaction,
-  SendOptions,
-} from "@solana/web3.js";
+import { PublicKey, Transaction, SendOptions } from "@solana/web3.js";
 import Decimal from "decimal.js";
 import * as ed from "@noble/ed25519";
-import { sha512 } from "@noble/hashes/sha512";
-ed.etc.sha512Sync = sha512;
 import { floatToScaledBigIntLossy } from "@n1xyz/proton";
 import {
   FillMode,
@@ -22,8 +15,8 @@ import {
   QuoteSize,
   TriggerKind,
   fillModeToProtoFillMode,
-} from "../../types";
-import * as proto from "../../gen/nord_pb";
+} from "../types";
+import * as proto from "../gen/nord_pb";
 import {
   BigIntValue,
   checkedFetch,
@@ -33,117 +26,19 @@ import {
   optExpect,
   keypairFromPrivateKey,
   toScaledU64,
-} from "../../utils";
+} from "../utils";
 import { create } from "@bufbuild/protobuf";
 import {
   createSession,
   revokeSession,
   atomic,
   expectReceiptKind,
+  createAction,
+  sendAction,
   AtomicSubaction,
-} from "../api/actions";
-import { NordError } from "../utils/NordError";
+} from "../actions";
+import { NordError } from "../error";
 import { Nord } from "./Nord";
-import { NordClient } from "./NordClient";
-
-/**
- * Parameters for creating a NordUser instance
- */
-export interface NordUserParams {
-  /** Nord client instance */
-  nord: Nord;
-
-  /** User's blockchain address */
-  address: string;
-
-  /** Function to sign messages with the user's wallet */
-  walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
-
-  /** Function to sign messages with the user's session key */
-  sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-
-  /** Function to sign transactions with the user's wallet (optional) */
-  transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
-
-  /** Solana connection (optional) */
-  connection?: Connection;
-
-  /** Session ID (optional) */
-  sessionId?: bigint;
-
-  /** Session public key (required) */
-  sessionPubKey: Uint8Array;
-
-  /** Session public key (required) */
-  publicKey: PublicKey;
-}
-
-/**
- * Parameters for placing an order
- */
-export interface PlaceOrderParams {
-  /** Market ID */
-  marketId: number;
-
-  /** Order side (bid or ask) */
-  side: Side;
-
-  /** Fill mode (limit, market, etc.) */
-  fillMode: FillMode;
-
-  /** Whether the order is reduce-only */
-  isReduceOnly: boolean;
-
-  /** Order size */
-  size?: Decimal.Value;
-
-  /** Order price */
-  price?: Decimal.Value;
-
-  /** Quote size object (requires non-zero price and size) */
-  quoteSize?: QuoteSize;
-
-  /** Account ID to place the order from */
-  accountId?: number;
-
-  clientOrderId?: BigIntValue;
-}
-
-export interface AddTriggerParams {
-  marketId: number;
-  side: Side;
-  kind: TriggerKind;
-  triggerPrice: Decimal.Value;
-  limitPrice?: Decimal.Value;
-  accountId?: number;
-}
-
-export interface RemoveTriggerParams {
-  marketId: number;
-  side: Side;
-  kind: TriggerKind;
-  accountId?: number;
-}
-
-/**
- * Parameters for transferring tokens between accounts
- */
-export interface TransferParams {
-  /** Recipient user */
-  to: NordUser;
-
-  /** Token ID to transfer */
-  tokenId: number;
-
-  /** Amount to transfer */
-  amount: Decimal.Value;
-
-  /** Source account ID */
-  fromAccountId: number;
-
-  /** Destination account ID */
-  toAccountId: number;
-}
 
 /**
  * Parameters for individual atomic subactions (user-friendly version)
@@ -183,7 +78,17 @@ export interface UserAtomicSubaction {
 /**
  * User class for interacting with the Nord protocol
  */
-export class NordUser extends NordClient {
+export class NordUser {
+  public readonly nord: Nord;
+  public readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+  public readonly transactionSignFn: (tx: Transaction) => Promise<Transaction>;
+  public sessionId?: bigint;
+  public sessionPubKey: PublicKey;
+  public publicKey: PublicKey;
+  public lastTs = 0;
+
+  private nonce = 0;
+
   /** User balances by token symbol */
   public balances: {
     [key: string]: { accountId: number; balance: number; symbol: string }[];
@@ -229,48 +134,35 @@ export class NordUser extends NordClient {
   /**
    * Create a new NordUser instance
    *
-   * @param params - Parameters for creating a NordUser
+   * @param nord - Nord client instance
+   * @param sessionSignFn - Function to sign messages with the user's session key
+   * @param transactionSignFn - Function to sign transactions with the user's wallet (optional)
+   * @param sessionId - Existing session identifier
+   * @param sessionPubKey - Session public key
+   * @param publicKey - Wallet public key
    * @throws {NordError} If required parameters are missing
    */
   constructor({
-    address,
     nord,
-    publicKey,
-    sessionPubKey,
     sessionSignFn,
     transactionSignFn,
-    walletSignFn,
-    connection,
     sessionId,
-  }: NordUserParams) {
-    if (!walletSignFn) {
-      throw new NordError("Wallet sign function is required");
-    }
-    if (!sessionSignFn) {
-      throw new NordError("Session sign function is required");
-    }
-    if (!sessionPubKey) {
-      throw new NordError("Session public key is required");
-    }
-
-    let parsedAddress: PublicKey;
-    try {
-      parsedAddress = new PublicKey(address);
-    } catch (error) {
-      throw new NordError("Invalid Solana address", { cause: error });
-    }
-
-    super({
-      nord,
-      address: parsedAddress,
-      walletSignFn,
-      sessionSignFn,
-      transactionSignFn,
-      connection,
-      sessionId,
-      sessionPubKey,
-      publicKey,
-    });
+    sessionPubKey,
+    publicKey,
+  }: Readonly<{
+    nord: Nord;
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    transactionSignFn: (tx: Transaction) => Promise<Transaction>;
+    sessionId?: bigint;
+    sessionPubKey: Uint8Array;
+    publicKey: PublicKey;
+  }>) {
+    this.nord = nord;
+    this.sessionSignFn = sessionSignFn;
+    this.transactionSignFn = transactionSignFn;
+    this.sessionId = sessionId;
+    this.sessionPubKey = new PublicKey(sessionPubKey);
+    this.publicKey = publicKey;
 
     // Convert tokens from info endpoint to SPLTokenInfo
     if (this.nord.tokens && this.nord.tokens.length > 0) {
@@ -283,74 +175,19 @@ export class NordUser extends NordClient {
     }
   }
 
-  /**
-   * Create a clone of this NordUser instance
-   *
-   * @returns A new NordUser instance with the same properties
-   */
-  clone(): NordUser {
-    const cloned = new NordUser({
-      nord: this.nord,
-      address: this.address.toBase58(),
-      walletSignFn: this.walletSignFn,
-      sessionSignFn: this.sessionSignFn,
-      transactionSignFn: this.transactionSignFn,
-      connection: this.connection,
-      sessionPubKey: new Uint8Array(this.sessionPubKey),
-      publicKey: this.publicKey,
-      sessionId: this.sessionId,
-    });
-
-    // Copy other properties
-    cloned.balances = { ...this.balances };
-    cloned.positions = { ...this.positions };
-    cloned.margins = { ...this.margins };
-    cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
-    cloned.splTokenInfos = [...this.splTokenInfos];
-    this.cloneClientState(cloned);
-
-    return cloned;
-  }
-
   /**
    * Create a NordUser from a private key
    *
    * @param nord - Nord instance
    * @param privateKey - Private key as string or Uint8Array
-   * @param connection - Solana connection (optional)
    * @returns NordUser instance
    * @throws {NordError} If the private key is invalid
    */
-  static fromPrivateKey(
-    nord: Nord,
-    privateKey: string | Uint8Array,
-    connection?: Connection,
-  ): NordUser {
+  static fromPrivateKey(nord: Nord, privateKey: string | Uint8Array): NordUser {
     try {
       const keypair = keypairFromPrivateKey(privateKey);
       const publicKey = keypair.publicKey;
 
-      // Create a signing function that uses the keypair but doesn't expose it
-      const walletSignFn = async (
-        message: Uint8Array | string,
-      ): Promise<Uint8Array> => {
-        function toHex(buffer: Uint8Array) {
-          return Array.from(buffer)
-            .map((byte) => byte.toString(16).padStart(2, "0"))
-            .join("");
-        }
-        const messageBuffer = new TextEncoder().encode(
-          toHex(message as Uint8Array),
-        );
-
-        // Use ed25519 to sign the message
-        const signature = ed.sign(
-          messageBuffer,
-          keypair.secretKey.slice(0, 32),
-        );
-        return signature;
-      };
-
       const sessionSignFn = async (
         message: Uint8Array,
       ): Promise<Uint8Array> => {
@@ -358,28 +195,19 @@ export class NordUser extends NordClient {
         return ed.sign(message, keypair.secretKey.slice(0, 32));
       };
 
-      // Create a transaction signing function
-      const transactionSignFn = async (transaction: any): Promise<any> => {
-        // This is a basic implementation - actual implementation would depend on the transaction type
-        if (transaction.sign) {
-          // Solana transaction
-          transaction.sign(keypair);
-          return transaction;
-        }
-
-        // For other transaction types, would need specific implementation
-        throw new NordError("Unsupported transaction type for signing");
+      const transactionSignFn = async (
+        tx: Transaction,
+      ): Promise<Transaction> => {
+        tx.sign(keypair);
+        return tx;
       };
 
       return new NordUser({
         nord,
-        address: publicKey.toBase58(),
-        walletSignFn,
         sessionSignFn,
         transactionSignFn,
-        connection,
         publicKey,
-        sessionPubKey: publicKey.toBytes(), // Use the public key derived from the private key as the session public key
+        sessionPubKey: publicKey.toBytes(),
       });
     } catch (error) {
       throw new NordError("Failed to create NordUser from private key", {
@@ -396,15 +224,9 @@ export class NordUser extends NordClient {
    * @throws {NordError} If required parameters are missing or operation fails
    */
   async getAssociatedTokenAccount(mint: PublicKey): Promise<PublicKey> {
-    if (!this.getSolanaPublicKey()) {
-      throw new NordError(
-        "Solana public key is required to get associated token account",
-      );
-    }
-
     try {
       // Get the token program ID from the mint account
-      const mintAccount = await this.connection.getAccountInfo(mint);
+      const mintAccount = await this.nord.solanaConnection.getAccountInfo(mint);
       if (!mintAccount) {
         throw new NordError("Mint account not found");
       }
@@ -422,7 +244,7 @@ export class NordUser extends NordClient {
 
       const associatedTokenAddress = await getAssociatedTokenAddress(
         mint,
-        this.getSolanaPublicKey(),
+        this.publicKey,
         false,
         tokenProgramId,
         ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -483,7 +305,7 @@ export class NordUser extends NordClient {
 
       const mint = new PublicKey(tokenInfo.mint);
       const fromAccount = await this.getAssociatedTokenAccount(mint);
-      const payer = this.getSolanaPublicKey();
+      const payer = this.publicKey;
 
       const { ix, extraSigner } = await this.nord.protonClient.buildDepositIx({
         payer,
@@ -493,7 +315,8 @@ export class NordUser extends NordClient {
         sourceTokenAccount: fromAccount,
       });
 
-      const { blockhash } = await this.connection.getLatestBlockhash();
+      const { blockhash } =
+        await this.nord.solanaConnection.getLatestBlockhash();
       const tx = new Transaction();
 
       tx.add(ix);
@@ -503,7 +326,7 @@ export class NordUser extends NordClient {
       const signedTx = await this.transactionSignFn(tx);
       signedTx.partialSign(extraSigner);
 
-      const signature = await this.connection.sendRawTransaction(
+      const signature = await this.nord.solanaConnection.sendRawTransaction(
         signedTx.serialize(),
         sendOptions,
       );
@@ -523,7 +346,7 @@ export class NordUser extends NordClient {
    * @returns Nonce as number
    */
   getNonce(): number {
-    return this.nextActionNonce();
+    return ++this.nonce;
   }
 
   private async submitSessionAction(
@@ -661,12 +484,12 @@ export class NordUser extends NordClient {
    */
   async refreshSession(): Promise<void> {
     const result = await createSession(
-      this.nord.webServerUrl,
-      this.walletSignFn,
+      this.nord.httpClient,
+      this.transactionSignFn,
       await this.nord.getTimestamp(),
       this.getNonce(),
       {
-        userPubkey: optExpect(this.publicKey.toBytes(), "No user's public key"),
+        userPubkey: this.publicKey,
         sessionPubkey: this.sessionPubKey,
       },
     );
@@ -681,11 +504,12 @@ export class NordUser extends NordClient {
   async revokeSession(sessionId: BigIntValue): Promise<void> {
     try {
       await revokeSession(
-        this.nord.webServerUrl,
-        this.walletSignFn,
+        this.nord.httpClient,
+        this.transactionSignFn,
         await this.nord.getTimestamp(),
         this.getNonce(),
         {
+          userPubkey: this.publicKey,
           sessionId,
         },
       );
@@ -751,29 +575,57 @@ export class NordUser extends NordClient {
   /**
    * Place an order on the exchange
    *
-   * @param params - Order parameters
+   * @param marketId - Target market identifier
+   * @param side - Order side
+   * @param fillMode - Fill mode (limit, market, etc.)
+   * @param isReduceOnly - Reduce-only flag
+   * @param size - Base size to place
+   * @param price - Limit price
+   * @param quoteSize - Quote-sized order representation
+   * @param accountId - Account executing the order
+   * @param clientOrderId - Optional client-specified identifier
    * @returns Object containing actionId, orderId (if posted), fills, and clientOrderId
    * @throws {NordError} If the operation fails
    */
-  async placeOrder(params: PlaceOrderParams): Promise<{
+  async placeOrder({
+    marketId,
+    side,
+    fillMode,
+    isReduceOnly,
+    size,
+    price,
+    quoteSize,
+    accountId,
+    clientOrderId,
+  }: Readonly<{
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: QuoteSize;
+    accountId?: number;
+    clientOrderId?: BigIntValue;
+  }>): Promise<{
     actionId: bigint;
     orderId?: bigint;
     fills: proto.Receipt_Trade[];
   }> {
     try {
       this.checkSessionValidity();
-      const market = findMarket(this.nord.markets, params.marketId);
+      const market = findMarket(this.nord.markets, marketId);
       if (!market) {
-        throw new NordError(`Market with ID ${params.marketId} not found`);
+        throw new NordError(`Market with ID ${marketId} not found`);
       }
       const sessionId = optExpect(this.sessionId, "No session");
-      const price = toScaledU64(params.price ?? 0, market.priceDecimals);
-      const size = toScaledU64(params.size ?? 0, market.sizeDecimals);
-      const scaledQuote = params.quoteSize
-        ? params.quoteSize.toWire(market.priceDecimals, market.sizeDecimals)
+      const scaledPrice = toScaledU64(price ?? 0, market.priceDecimals);
+      const scaledSize = toScaledU64(size ?? 0, market.sizeDecimals);
+      const scaledQuote = quoteSize
+        ? quoteSize.toWire(market.priceDecimals, market.sizeDecimals)
         : undefined;
       assert(
-        price > 0n || size > 0n || scaledQuote !== undefined,
+        scaledPrice > 0n || scaledSize > 0n || scaledQuote !== undefined,
         "OrderLimit must include at least one of: size, price, or quoteSize",
       );
 
@@ -781,13 +633,13 @@ export class NordUser extends NordClient {
         case: "placeOrder",
         value: create(proto.Action_PlaceOrderSchema, {
           sessionId: BigInt(sessionId),
-          senderAccountId: params.accountId,
-          marketId: params.marketId,
-          side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
-          fillMode: fillModeToProtoFillMode(params.fillMode),
-          isReduceOnly: params.isReduceOnly,
-          price,
-          size,
+          senderAccountId: accountId,
+          marketId,
+          side: side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+          fillMode: fillModeToProtoFillMode(fillMode),
+          isReduceOnly,
+          price: scaledPrice,
+          size: scaledSize,
           quoteSize:
             scaledQuote === undefined
               ? undefined
@@ -796,9 +648,7 @@ export class NordUser extends NordClient {
                   price: scaledQuote.price,
                 }),
           clientOrderId:
-            params.clientOrderId === undefined
-              ? undefined
-              : BigInt(params.clientOrderId),
+            clientOrderId === undefined ? undefined : BigInt(clientOrderId),
         }),
       });
       expectReceiptKind(receipt, "placeOrderResult", "place order");
@@ -857,48 +707,67 @@ export class NordUser extends NordClient {
   /**
    * Add a trigger for the current session
    *
-   * @param params - Trigger parameters including market, side, and prices
+   * @param marketId - Market to watch
+   * @param side - Order side for the trigger
+   * @param kind - Stop-loss or take-profit trigger type
+   * @param triggerPrice - Price that activates the trigger
+   * @param limitPrice - Limit price placed once the trigger fires
+   * @param accountId - Account executing the trigger
    * @returns Object containing the actionId of the submitted trigger
    * @throws {NordError} If the operation fails
    */
-  async addTrigger(params: AddTriggerParams): Promise<{ actionId: bigint }> {
+  async addTrigger({
+    marketId,
+    side,
+    kind,
+    triggerPrice,
+    limitPrice,
+    accountId,
+  }: Readonly<{
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    triggerPrice: Decimal.Value;
+    limitPrice?: Decimal.Value;
+    accountId?: number;
+  }>): Promise<{ actionId: bigint }> {
     try {
       this.checkSessionValidity();
-      const market = findMarket(this.nord.markets, params.marketId);
+      const market = findMarket(this.nord.markets, marketId);
       if (!market) {
-        throw new NordError(`Market with ID ${params.marketId} not found`);
+        throw new NordError(`Market with ID ${marketId} not found`);
       }
-      const triggerPrice = toScaledU64(
-        params.triggerPrice,
+      const scaledTriggerPrice = toScaledU64(
+        triggerPrice,
         market.priceDecimals,
       );
-      assert(triggerPrice > 0n, "Trigger price must be positive");
-      const limitPrice =
-        params.limitPrice === undefined
+      assert(scaledTriggerPrice > 0n, "Trigger price must be positive");
+      const scaledLimitPrice =
+        limitPrice === undefined
           ? undefined
-          : toScaledU64(params.limitPrice, market.priceDecimals);
-      if (limitPrice !== undefined) {
-        assert(limitPrice > 0n, "Limit price must be positive");
+          : toScaledU64(limitPrice, market.priceDecimals);
+      if (scaledLimitPrice !== undefined) {
+        assert(scaledLimitPrice > 0n, "Limit price must be positive");
       }
       const key = create(proto.TriggerKeySchema, {
         kind:
-          params.kind === TriggerKind.StopLoss
+          kind === TriggerKind.StopLoss
             ? proto.TriggerKind.STOP_LOSS
             : proto.TriggerKind.TAKE_PROFIT,
-        side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+        side: side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
       });
       const prices = create(proto.Action_TriggerPricesSchema, {
-        triggerPrice,
-        limitPrice,
+        triggerPrice: scaledTriggerPrice,
+        limitPrice: scaledLimitPrice,
       });
       const receipt = await this.submitSessionAction({
         case: "addTrigger",
         value: create(proto.Action_AddTriggerSchema, {
           sessionId: BigInt(optExpect(this.sessionId, "No session")),
-          marketId: params.marketId,
+          marketId,
           key,
           prices,
-          accountId: params.accountId,
+          accountId,
         }),
       });
       expectReceiptKind(receipt, "triggerAdded", "add trigger");
@@ -911,33 +780,44 @@ export class NordUser extends NordClient {
   /**
    * Remove a trigger for the current session
    *
-   * @param params - Trigger parameters identifying the trigger to remove
+   * @param marketId - Market the trigger belongs to
+   * @param side - Order side for the trigger
+   * @param kind - Stop-loss or take-profit trigger type
+   * @param accountId - Account executing the trigger
    * @returns Object containing the actionId of the removal action
    * @throws {NordError} If the operation fails
    */
-  async removeTrigger(
-    params: RemoveTriggerParams,
-  ): Promise<{ actionId: bigint }> {
+  async removeTrigger({
+    marketId,
+    side,
+    kind,
+    accountId,
+  }: Readonly<{
+    marketId: number;
+    side: Side;
+    kind: TriggerKind;
+    accountId?: number;
+  }>): Promise<{ actionId: bigint }> {
     try {
       this.checkSessionValidity();
-      const market = findMarket(this.nord.markets, params.marketId);
+      const market = findMarket(this.nord.markets, marketId);
       if (!market) {
-        throw new NordError(`Market with ID ${params.marketId} not found`);
+        throw new NordError(`Market with ID ${marketId} not found`);
       }
       const key = create(proto.TriggerKeySchema, {
         kind:
-          params.kind === TriggerKind.StopLoss
+          kind === TriggerKind.StopLoss
             ? proto.TriggerKind.STOP_LOSS
             : proto.TriggerKind.TAKE_PROFIT,
-        side: params.side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
+        side: side === Side.Bid ? proto.Side.BID : proto.Side.ASK,
       });
       const receipt = await this.submitSessionAction({
         case: "removeTrigger",
         value: create(proto.Action_RemoveTriggerSchema, {
           sessionId: BigInt(optExpect(this.sessionId, "No session")),
-          marketId: params.marketId,
+          marketId,
           key,
-          accountId: params.accountId,
+          accountId,
         }),
       });
       expectReceiptKind(receipt, "triggerRemoved", "remove trigger");
@@ -950,16 +830,32 @@ export class NordUser extends NordClient {
   /**
    * Transfer tokens to another account
    *
-   * @param params - Transfer parameters
+   * @param tokenId - Token identifier to move
+   * @param amount - Amount to transfer
+   * @param fromAccountId - Source account id
+   * @param toAccountId - Destination account id
    * @throws {NordError} If the operation fails
    */
-  async transferToAccount(params: TransferParams): Promise<void> {
+  async transferToAccount({
+    tokenId,
+    amount,
+    fromAccountId,
+    toAccountId,
+  }: Readonly<{
+    tokenId: number;
+    amount: Decimal.Value;
+    fromAccountId?: number;
+    toAccountId?: number;
+  }>): Promise<{
+    actionId: bigint;
+    newAccountId?: number;
+  }> {
     try {
       this.checkSessionValidity();
-      const token = findToken(this.nord.tokens, params.tokenId);
+      const token = findToken(this.nord.tokens, tokenId);
 
-      const amount = toScaledU64(params.amount, token.decimals);
-      if (amount <= 0n) {
+      const scaledAmount = toScaledU64(amount, token.decimals);
+      if (scaledAmount <= 0n) {
         throw new NordError("Transfer amount must be positive");
       }
 
@@ -967,13 +863,25 @@ export class NordUser extends NordClient {
         case: "transfer",
         value: create(proto.Action_TransferSchema, {
           sessionId: BigInt(optExpect(this.sessionId, "No session")),
-          fromAccountId: optExpect(params.fromAccountId, "No source account"),
-          toAccountId: optExpect(params.toAccountId, "No target account"),
-          tokenId: params.tokenId,
-          amount,
+          fromAccountId: optExpect(fromAccountId, "No source account"),
+          toAccountId: optExpect(toAccountId, "No target account"),
+          tokenId,
+          amount: scaledAmount,
         }),
       });
       expectReceiptKind(receipt, "transferred", "transfer tokens");
+      if (receipt.kind.value.accountCreated) {
+        assert(
+          receipt.kind.value.toUserAccount !== undefined,
+          `toAccount must be defined on new account on ${receipt.kind.value}`,
+        );
+        return {
+          actionId: receipt.actionId,
+          newAccountId: receipt.kind.value.toUserAccount,
+        };
+      } else {
+        return { actionId: receipt.actionId };
+      }
     } catch (error) {
       throw new NordError("Failed to transfer tokens", { cause: error });
     }
@@ -1037,7 +945,7 @@ export class NordUser extends NordClient {
       });
 
       const result = await atomic(
-        this.nord.webServerUrl,
+        this.nord.httpClient,
         this.sessionSignFn,
         await this.nord.getTimestamp(),
         this.getNonce(),
@@ -1124,24 +1032,18 @@ export class NordUser extends NordClient {
       maxRetries = 3,
     } = options;
 
-    if (!this.connection || !this.getSolanaPublicKey()) {
-      throw new NordError(
-        "Connection and Solana public key are required to get Solana balances",
-      );
-    }
-
     const balances: { [symbol: string]: number } = {};
     const tokenAccounts: { [symbol: string]: string } = {};
 
     try {
       // Get SOL balance (native token)
       const solBalance = await this.retryWithBackoff(
-        () => this.connection!.getBalance(this.getSolanaPublicKey()),
+        () => this.nord.solanaConnection.getBalance(this.publicKey),
         maxRetries,
       );
       balances["SOL"] = solBalance / 1e9; // Convert lamports to SOL
       if (includeTokenAccounts) {
-        tokenAccounts["SOL"] = this.getSolanaPublicKey().toString();
+        tokenAccounts["SOL"] = this.publicKey.toString();
       }
 
       // Get SPL token balances using mintAddr from Nord tokens
@@ -1157,8 +1059,7 @@ export class NordUser extends NordClient {
             try {
               const mint = new PublicKey(token.mintAddr);
               const associatedTokenAddress = await this.retryWithBackoff(
-                () =>
-                  getAssociatedTokenAddress(mint, this.getSolanaPublicKey()),
+                () => getAssociatedTokenAddress(mint, this.publicKey),
                 maxRetries,
               );
 
@@ -1169,7 +1070,7 @@ export class NordUser extends NordClient {
               try {
                 const tokenBalance = await this.retryWithBackoff(
                   () =>
-                    this.connection.getTokenAccountBalance(
+                    this.nord.solanaConnection.getTokenAccountBalance(
                       associatedTokenAddress,
                     ),
                   maxRetries,
@@ -1208,4 +1109,14 @@ export class NordUser extends NordClient {
       });
     }
   }
+
+  protected async submitSignedAction(
+    kind: proto.Action["kind"],
+    makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>,
+  ): Promise<proto.Receipt> {
+    const nonce = this.getNonce();
+    const currentTimestamp = await this.nord.getTimestamp();
+    const action = createAction(currentTimestamp, nonce, kind);
+    return sendAction(this.nord.httpClient, makeSignedMessage, action);
+  }
 }