Transaction Signing

import * as nacl from 'tweetnacl';
import bs58 from 'bs58';

// --- Primitive writers (little-endian, fixed-width, bincode-compatible) ---

function writeU8(value: number): Uint8Array {
  return new Uint8Array([value & 0xff]);
}

function writeU32(value: number): Uint8Array {
  const buf = new Uint8Array(4);
  new DataView(buf.buffer).setUint32(0, value, true);
  return buf;
}

function writeI16(value: number): Uint8Array {
  const buf = new Uint8Array(2);
  new DataView(buf.buffer).setInt16(0, value, true);
  return buf;
}

function writeU64(value: number | bigint): Uint8Array {
  const buf = new Uint8Array(8);
  new DataView(buf.buffer).setBigUint64(0, BigInt(value), true);
  return buf;
}

function writeF64(value: number): Uint8Array {
  const buf = new Uint8Array(8);
  new DataView(buf.buffer).setFloat64(0, value, true);
  return buf;
}

function writeBool(value: boolean): Uint8Array {
  return new Uint8Array([value ? 1 : 0]);
}

function writeString(str: string): Uint8Array {
  const bytes = new TextEncoder().encode(str);
  return concatBytes(writeU64(bytes.length), bytes);
}

function concatBytes(...arrays: Uint8Array[]): Uint8Array {
  const total = arrays.reduce((s, a) => s + a.length, 0);
  const out = new Uint8Array(total);
  let off = 0;
  for (const a of arrays) { out.set(a, off); off += a.length; }
  return out;
}

// --- Exchange fixed-point convention ---

const SCALE = 1e8;

/** Scaled f64: encoded as u64 LE of round(x * 1e8). */
function writeScaled(value: number): Uint8Array {
  const fixed = Math.round(value * SCALE);
  if (!Number.isFinite(fixed) || fixed < 0) {
    throw new Error(`scaled value must be a finite non-negative number (got ${value})`);
  }
  return writeU64(BigInt(fixed));
}

/** Option<scaled f64>: 1-byte tag + (if Some) u64 LE scaled. */
function writeOptScaled(value: number | null | undefined): Uint8Array {
  if (value === null || value === undefined) return writeU8(0);
  return concatBytes(writeU8(1), writeScaled(value));
}

/** Option<plain f64>: 1-byte tag + (if Some) raw IEEE-754 f64 LE. */
function writeOptF64(value: number | null | undefined): Uint8Array {
  if (value === null || value === undefined) return writeU8(0);
  return concatBytes(writeU8(1), writeF64(value));
}

/**
 * CommissionSignableActions omits builderCode completely when absent. When
 * present, it encodes Option::Some as tag(1) + recipient pubkey + fee bps.
 */
function writeBuilderCode(value: {to: string, fee: number} | null | undefined): Uint8Array {
  if (value === null || value === undefined) return new Uint8Array();
  return concatBytes(writeU8(1), bs58.decode(value.to), writeU8(value.fee));
}

// Each action body starts with a u32 LE discriminant.

const TIF_CODES: Record<string, number> = { GTC: 0, IOC: 1, ALO: 2, ALO_SLIDE: 3, ALO_JOIN: 4 };

function serializeMarketOrder(o: any): Uint8Array {
  return concatBytes(
    writeU32(0),                    // discriminant
    writeString(o.c),               // symbol
    writeBool(o.b),                 // is_buy
    writeScaled(o.sz),              // size (scaled u64)
    writeBool(o.r),                 // reduce_only
    writeBool(!!o.i),               // iso (default false)
    writeBuilderCode(o.builderCode), // optional builder-code fee
  );
}

function serializeLimitOrder(o: any): Uint8Array {
  return concatBytes(
    writeU32(1),                    // discriminant
    writeString(o.c),               // symbol
    writeBool(o.b),                 // is_buy
    writeScaled(o.px),              // price (scaled u64)
    writeScaled(o.sz),              // size  (scaled u64)
    writeU32(TIF_CODES[o.tif] ?? 0),// tif   (u32 LE variant index)
    writeBool(o.r),                 // reduce_only
    writeBool(!!o.i),               // iso (default false)
    writeBuilderCode(o.builderCode), // optional builder-code fee
  );
}

function serializeModifyOrder(d: any): Uint8Array {
  return concatBytes(
    writeU32(2),                    // discriminant
    bs58.decode(d.oid),             // order ID (32 bytes)
    writeString(d.c),               // symbol
    writeF64(d.sz),                 // amount (plain f64, NOT scaled)
  );
}

function serializeCancel(d: any): Uint8Array {
  return concatBytes(
    writeU32(3),                    // discriminant
    writeString(d.c),               // symbol
    bs58.decode(d.oid),             // order ID (32 bytes)
  );
}

function serializeCancelAll(d: any): Uint8Array {
  const parts: Uint8Array[] = [writeU32(4), writeU64(d.c.length)];
  for (const sym of d.c) parts.push(writeString(sym));
  return concatBytes(...parts);
}

// Stop (5) and TakeProfit (6) share the same body layout.
function serializeStopOrTP(disc: 5 | 6, d: any): Uint8Array {
  return concatBytes(
    writeU32(disc),                 // discriminant
    writeString(d.c),               // symbol
    writeBool(d.d),                 // trigger direction (is_above)
    writeScaled(d.sz),              // size      (scaled u64)
    writeScaled(d.tr),              // threshold (scaled u64)
    writeOptScaled(d.lim),          // limit     (Option<scaled u64>)
    writeBool(!!d.i),               // iso (default false)
  );
}

function serializeRange(d: any): Uint8Array {
  return concatBytes(
    writeU32(7),                    // discriminant
    writeString(d.c),               // symbol
    writeBool(d.d),                 // position direction
    writeScaled(d.sz),              // size        (scaled u64)
    writeScaled(d.pmin),            // collar_min  (scaled u64)
    writeScaled(d.pmax),            // collar_max  (scaled u64)
    writeOptScaled(d.lmin),         // limit_min   (Option<scaled u64>)
    writeOptScaled(d.lmax),         // limit_max   (Option<scaled u64>)
    writeBool(!!d.i),               // iso (default false)
  );
}

function serializeTriggerBasket(d: any): Uint8Array {
  const nested = d.actions || [];
  const parts: Uint8Array[] = [
    writeU32(8),                    // discriminant
    writeString(d.c),               // symbol
    writeBool(d.d),                 // trigger direction
    writeScaled(d.tr),              // threshold  (scaled u64)
    writeU64(nested.length),        // nested action count
  ];
  for (const n of nested) parts.push(serializeAction(n));
  return concatBytes(...parts);
}

function serializeTrailing(d: any): Uint8Array {
  return concatBytes(
    writeU32(9),                    // discriminant
    writeString(d.c),               // symbol
    writeBool(d.b),                 // position direction (is_buy)
    writeScaled(d.sz),              // size      (scaled u64)
    writeU32(d.trb),                // trail_bps (u32)
    writeU32(d.stb),                // step_bps  (u32)
    writeOptScaled(d.lim),          // limit     (Option<scaled u64>)
    writeBool(!!d.i),               // iso (default false)
  );
}

function serializeOnFill(d: any): Uint8Array {
  const nested = d.actions || [];
  const parts: Uint8Array[] = [
    writeU32(10),                   // discriminant
    serializeAction(d.trigger),     // action that triggers on its first fill
    writeU64(nested.length),        // consequent action count
  ];
  for (const n of nested) parts.push(serializeAction(n));
  return concatBytes(...parts);
}

function serializePrice(d: any): Uint8Array {
  return concatBytes(
    writeU32(11),                   // discriminant
    writeU64(d.t),                  // timestamp
    writeString(d.c),               // asset
    writeF64(d.px),                 // price (plain f64, NOT scaled)
  );
}

function serializePythOracle(d: any): Uint8Array {
  const oracles = d.oracles || [];
  const parts: Uint8Array[] = [writeU32(13), writeU64(oracles.length)];
  for (const o of oracles) {
    parts.push(
      writeU64(o.t),                // timestamp
      writeU64(o.fi),               // feed id
      writeU64(o.px),               // price (raw u64)
      writeI16(o.e),                // exponent
    );
  }
  return concatBytes(...parts);
}

function serializeFaucet(d: any): Uint8Array {
  return concatBytes(
    writeU32(16),                   // discriminant
    bs58.decode(d.u),               // user pubkey
    writeOptF64(d.amount),          // amount (Option<plain f64>)
  );
}

function serializeAgentWalletCreation(d: any): Uint8Array {
  return concatBytes(
    writeU32(17),                   // discriminant
    bs58.decode(d.a),               // agent pubkey
    writeBool(d.d),                 // delete flag
  );
}

function serializeUpdateUserSettings(d: any): Uint8Array {
  const entries = Object.entries(d.m || {}) as [string, number][];
  // NOTE: server deserializes into HashMap<String, f64>. If you sign more than one
  // entry you MUST use the same iteration order as the server would on re-serialize.
  // Today the safest path is to submit a single-entry map at a time.
  const parts: Uint8Array[] = [writeU32(18), writeU64(entries.length)];
  for (const [sym, lev] of entries) {
    parts.push(writeString(sym), writeF64(lev)); // leverage is plain f64
  }
  return concatBytes(...parts);
}

function serializeWhitelistFaucet(d: any): Uint8Array {
  return concatBytes(
    writeU32(19),                   // discriminant
    bs58.decode(d.target),          // target pubkey
    writeBool(d.whitelist),         // whitelist flag
  );
}

function serializeApproveBuilderCode(d: any): Uint8Array {
  return concatBytes(
    writeU32(40),                   // discriminant
    bs58.decode(d.to),              // recipient pubkey
    writeU8(d.fee),                 // max fee bps
  );
}

function serializeRevokeBuilderCode(d: any): Uint8Array {
  return concatBytes(
    writeU32(41),                   // discriminant
    bs58.decode(d.to),              // recipient pubkey
  );
}

function serializeAction(action: any): Uint8Array {
  const [type, data] = Object.entries(action)[0] as [string, any];
  switch (type) {
    case 'm':                     return serializeMarketOrder(data);
    case 'l':                     return serializeLimitOrder(data);
    case 'mod':                   return serializeModifyOrder(data);
    case 'cx':                    return serializeCancel(data);
    case 'cxa':                   return serializeCancelAll(data);
    case 'st':                    return serializeStopOrTP(5, data);
    case 'tp':                    return serializeStopOrTP(6, data);
    case 'rng':                   return serializeRange(data);
    case 'trig':                  return serializeTriggerBasket(data);
    case 'trl':                   return serializeTrailing(data);
    case 'of':                    return serializeOnFill(data);
    case 'px':                    return serializePrice(data);
    case 'o':                     return serializePythOracle(data);
    case 'faucet':                return serializeFaucet(data);
    case 'agentWalletCreation':   return serializeAgentWalletCreation(data);
    case 'abc':                   return serializeApproveBuilderCode(data);
    case 'rbc':                   return serializeRevokeBuilderCode(data);
    case 'updateUserSettings':    return serializeUpdateUserSettings(data);
    case 'whitelistFaucet':       return serializeWhitelistFaucet(data);
    default: throw new Error(`Unknown action: ${type}`);
  }
}

function serializeTransaction(
  actions: any[],
  nonce: number | bigint,
  account: string,
  signatureDomain: 1 | 2 | 3,
): Uint8Array {
  const parts: Uint8Array[] = [writeU64(actions.length)];
  for (const action of actions) parts.push(serializeAction(action));
  parts.push(writeU64(nonce));
  parts.push(bs58.decode(account));   // 32 bytes
  parts.push(Uint8Array.of(signatureDomain));
  return concatBytes(...parts);
}

function signTransaction(
  secretKey: Uint8Array,
  actions: any[],
  nonce: number | bigint,
  account: string,
  signatureDomain: 1 | 2 | 3,
): string {
  const message = serializeTransaction(actions, nonce, account, signatureDomain);
  const signature = nacl.sign.detached(message, secretKey);
  return bs58.encode(signature);
}

// --- Usage ---

const account = "9J8TUdEWrrcADK913r1Cs7DdqX63VdVU88imfDzT1ypt";
const signer = account;
const secretKey = bs58.decode("YOUR_SECRET_KEY_BASE58"); // 64 bytes
const nonce = Date.now();
const signatureDomain = 1; // mainnet=1, testnet=2, devnet=3

const actions = [
  { l: { c: "BTC-USD", b: true, px: 100000.0, sz: 0.1, tif: "GTC", r: false, i: false } },
];

const signature = signTransaction(secretKey, actions, nonce, account, signatureDomain);

const tx = { actions, nonce, account, signer, signature };

await fetch('https://mainnet-api1.bulk.trade/api/v1/order', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(tx),
});