@acta-markets/ts-sdk 0.0.1-beta

package/dist/cjs/idl/hash.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTA_IDL_SHA256 = void 0;
+exports.ACTA_IDL_SHA256 = "1466fbb647b4c33af315eefbb61e5e572ce14f22f16d050ac2894f8e017aaf66";

package/dist/cjs/index.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTA_IDL_SHA256 = exports.ACTA_PROGRAM_ID = exports.ACTA_IDL = exports.ActaChainClient = exports.CustomAuthProvider = exports.WalletAuthProvider = exports.KeypairAuthProvider = exports.ActaWsClient = exports.types = exports.chain = exports.ws = void 0;
+exports.getActaProgramId = getActaProgramId;
+exports.setActaProgramId = setActaProgramId;
+exports.clearActaProgramId = clearActaProgramId;
+const acta_contract_json_1 = __importDefault(require("./idl/acta_contract.json"));
+const hash_1 = require("./idl/hash");
+Object.defineProperty(exports, "ACTA_IDL_SHA256", { enumerable: true, get: function () { return hash_1.ACTA_IDL_SHA256; } });
+const programs_1 = require("./generated/programs");
+__exportStar(require("./constants"), exports);
+__exportStar(require("./generated/accounts"), exports);
+__exportStar(require("./generated/errors"), exports);
+__exportStar(require("./generated/instructions"), exports);
+__exportStar(require("./generated/types"), exports);
+__exportStar(require("./actaClient"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./nonce"), exports);
+// New SDK surface (namespaced).
+exports.ws = __importStar(require("./ws"));
+exports.chain = __importStar(require("./chain"));
+exports.types = __importStar(require("./types"));
+var client_1 = require("./ws/client");
+Object.defineProperty(exports, "ActaWsClient", { enumerable: true, get: function () { return client_1.ActaWsClient; } });
+var auth_1 = require("./ws/auth");
+Object.defineProperty(exports, "KeypairAuthProvider", { enumerable: true, get: function () { return auth_1.KeypairAuthProvider; } });
+Object.defineProperty(exports, "WalletAuthProvider", { enumerable: true, get: function () { return auth_1.WalletAuthProvider; } });
+Object.defineProperty(exports, "CustomAuthProvider", { enumerable: true, get: function () { return auth_1.CustomAuthProvider; } });
+var client_2 = require("./chain/client");
+Object.defineProperty(exports, "ActaChainClient", { enumerable: true, get: function () { return client_2.ActaChainClient; } });
+__exportStar(require("./chain/tx"), exports);
+exports.ACTA_IDL = acta_contract_json_1.default;
+// --- Program ID override (useful for tests/devnet deployments) ---
+let PROGRAM_ID_OVERRIDE = null;
+function getActaProgramId() {
+    return (PROGRAM_ID_OVERRIDE ?? programs_1.ACTA_CONTRACT_PROGRAM_ADDRESS);
+}
+function setActaProgramId(programId) {
+    PROGRAM_ID_OVERRIDE = programId;
+}
+function clearActaProgramId() {
+    PROGRAM_ID_OVERRIDE = null;
+}
+// Default program id exports.
+exports.ACTA_PROGRAM_ID = programs_1.ACTA_CONTRACT_PROGRAM_ADDRESS;

package/dist/cjs/nonce.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Nonce helpers for maker quotes.
+ *
+ * IMPORTANT:
+ * - If you don't pass a seed, the SDK will try to use `crypto.getRandomValues`.
+ * - If no crypto source is available, you MUST provide a 32-byte seed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonceGenerator = void 0;
+const MASK_64 = (1n << 64n) - 1n;
+const MAX_SAFE_U64 = (1n << 53n) - 1n;
+const SEED_SIZE = 32;
+function u64(x) {
+    return x & MASK_64;
+}
+function rotl(x, k) {
+    return u64((x << k) | (x >> (64n - k)));
+}
+function readU64LE(bytes, offset) {
+    let out = 0n;
+    for (let i = 7; i >= 0; i--) {
+        out = (out << 8n) | BigInt(bytes[offset + i]);
+    }
+    return out;
+}
+function ensureNonZeroState(state) {
+    if ((state[0] | state[1] | state[2] | state[3]) === 0n) {
+        throw new Error("nonce seed must not be all zeros");
+    }
+}
+function makeSeed() {
+    if (globalThis.crypto?.getRandomValues) {
+        const seed = new Uint8Array(SEED_SIZE);
+        globalThis.crypto.getRandomValues(seed);
+        return seed;
+    }
+    throw new Error("no crypto.getRandomValues available; provide a 32-byte seed explicitly");
+}
+/**
+ * Xoshiro256++ nonce generator (fast, deterministic).
+ * Seed can be passed explicitly (recommended for reproducibility),
+ * or generated internally if crypto.getRandomValues is available.
+ */
+class NonceGenerator {
+    s0;
+    s1;
+    s2;
+    s3;
+    seed;
+    constructor(seed) {
+        const resolvedSeed = seed ? new Uint8Array(seed) : makeSeed();
+        if (resolvedSeed.length !== SEED_SIZE) {
+            throw new Error(`nonce seed must be 32 bytes, got ${resolvedSeed.length}`);
+        }
+        const state = [
+            readU64LE(resolvedSeed, 0),
+            readU64LE(resolvedSeed, 8),
+            readU64LE(resolvedSeed, 16),
+            readU64LE(resolvedSeed, 24),
+        ];
+        ensureNonZeroState(state);
+        this.s0 = u64(state[0]);
+        this.s1 = u64(state[1]);
+        this.s2 = u64(state[2]);
+        this.s3 = u64(state[3]);
+        this.seed = resolvedSeed;
+    }
+    /** Return a copy of the seed used to initialize this generator. */
+    getSeed() {
+        return new Uint8Array(this.seed);
+    }
+    /** Return next raw u64 (as bigint). */
+    nextU64() {
+        const result = u64(rotl(u64(this.s0 + this.s3), 23n) + this.s0);
+        const t = u64(this.s1 << 17n);
+        this.s2 ^= this.s0;
+        this.s3 ^= this.s1;
+        this.s1 ^= this.s2;
+        this.s0 ^= this.s3;
+        this.s2 ^= t;
+        this.s3 = rotl(this.s3, 45n);
+        return result;
+    }
+    /**
+     * Return a nonce safe for JSON (`number`).
+     * Uses lower 53 bits to avoid precision loss.
+     */
+    nextNonce() {
+        return Number(this.nextU64() & MAX_SAFE_U64);
+    }
+}
+exports.NonceGenerator = NonceGenerator;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./orders"), exports);
+__exportStar(require("./orderId"), exports);

package/dist/cjs/types/orderId.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Canonical OrderId representation across the SDK.
+ *
+ * Contract expects `orderId` as **32 bytes**: `sha256(order_preimage_182)`.
+ *
+ * - In TypeScript we represent it as `Uint8Array` of length 32.
+ * - For JSON/Wire formats we typically use **hex** (64 chars) when needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertOrderId32 = assertOrderId32;
+exports.orderIdToHex = orderIdToHex;
+exports.orderIdFromHex = orderIdFromHex;
+function assertOrderId32(orderId) {
+    if (!(orderId instanceof Uint8Array)) {
+        throw new Error("orderId must be a Uint8Array");
+    }
+    if (orderId.length !== 32) {
+        throw new Error(`orderId must be 32 bytes, got ${orderId.length}`);
+    }
+}
+function orderIdToHex(orderId) {
+    assertOrderId32(orderId);
+    return Buffer.from(orderId).toString("hex");
+}
+function orderIdFromHex(hex) {
+    if (typeof hex !== "string") {
+        throw new Error("orderId hex must be a string");
+    }
+    const cleaned = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (cleaned.length !== 64) {
+        throw new Error(`orderId hex must be 64 hex chars (32 bytes), got ${cleaned.length}`);
+    }
+    if (!/^[0-9a-fA-F]+$/.test(cleaned)) {
+        throw new Error("orderId hex contains non-hex characters");
+    }
+    const bytes = Uint8Array.from(Buffer.from(cleaned, "hex"));
+    assertOrderId32(bytes);
+    return bytes;
+}

package/dist/cjs/types/orders.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * SDK-level order-related *types*.
+ *
+ * These types are shared across on-chain flows and any off-chain tooling that needs
+ * to construct or reason about order preimages / orderIds.
+ *
+ * Implementation lives in `src/chain/orders.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ws/apy.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * APY / annualized premium yield helpers for WS-only frontends.
+ *
+ * Goal: given a quote premium and an option term, compute:
+ * - "how much premium will I receive?" (notional)
+ * - "what is that as APR/APY?" (annualized)
+ *
+ * This is a display metric (premium / collateral), NOT an expected return model.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECONDS_PER_YEAR = exports.PRICE_SCALE = void 0;
+exports.annualizeYield = annualizeYield;
+exports.termYieldFromNotionals = termYieldFromNotionals;
+exports.computeApyFromAmounts = computeApyFromAmounts;
+exports.scaledPriceToFloat = scaledPriceToFloat;
+exports.computeApyFromScaledPrices = computeApyFromScaledPrices;
+exports.PRICE_SCALE = 1_000_000_000;
+exports.SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+/** Annualize a term yield over `secondsToExpiry`. */
+function annualizeYield(args) {
+    const y = args.termYield;
+    const dt = args.secondsToExpiry;
+    if (!Number.isFinite(y) || y < 0)
+        throw new Error("invalid termYield");
+    if (!Number.isFinite(dt) || dt <= 0)
+        return { apr: 0, apy: 0 };
+    const yearOverDt = exports.SECONDS_PER_YEAR / dt;
+    const apr = y * yearOverDt;
+    const apy = Math.pow(1 + y, yearOverDt) - 1;
+    return { apr, apy };
+}
+/** term_yield = premium_notional / collateral_notional */
+function termYieldFromNotionals(args) {
+    const p = args.premiumNotional;
+    const c = args.collateralNotional;
+    if (!Number.isFinite(p) || p < 0)
+        throw new Error("invalid premiumNotional");
+    if (!Number.isFinite(c) || c <= 0)
+        throw new Error("invalid collateralNotional");
+    return p / c;
+}
+/**
+ * Compute premium/collateral notionals and APR/APY from *human unit* amounts.
+ *
+ * Example (your case):
+ * - covered_call
+ * - underlyingAmount = 10 SOL
+ * - spotPrice = 150 USD/SOL  => collateralNotional = 1500 USD
+ * - premiumPerUnderlying = 1.5 USD/SOL => premiumNotional = 15 USD
+ * - 7 days => ~52% APR (simple)
+ */
+function computeApyFromAmounts(args) {
+    const qty = args.underlyingAmount;
+    if (!Number.isFinite(qty) || qty <= 0)
+        throw new Error("invalid underlyingAmount");
+    const premPU = args.premiumPerUnderlying;
+    if (!Number.isFinite(premPU) || premPU < 0)
+        throw new Error("invalid premiumPerUnderlying");
+    const premiumNotional = qty * premPU;
+    let collateralPerUnderlying;
+    if (args.positionType === "cash_secured_put") {
+        collateralPerUnderlying = args.strikePrice;
+    }
+    else {
+        collateralPerUnderlying = args.spotPrice ?? NaN;
+    }
+    if (!Number.isFinite(collateralPerUnderlying) || collateralPerUnderlying <= 0) {
+        throw new Error(args.positionType === "covered_call"
+            ? "spotPrice is required for covered_call yield"
+            : "invalid strikePrice");
+    }
+    const collateralNotional = qty * collateralPerUnderlying;
+    const termYield = termYieldFromNotionals({ premiumNotional, collateralNotional });
+    const { apr, apy } = annualizeYield({ termYield, secondsToExpiry: args.secondsToExpiry });
+    return { premiumNotional, collateralNotional, termYield, apr, apy };
+}
+function toNum(v) {
+    // Note: bigint->number can lose precision for huge values; acceptable for UI display.
+    return typeof v === "bigint" ? Number(v) : v;
+}
+/** Convert a 1e9-scaled u64 price into a float price. */
+function scaledPriceToFloat(price1e9) {
+    const n = toNum(price1e9);
+    if (!Number.isFinite(n))
+        throw new Error("invalid price1e9");
+    return n / exports.PRICE_SCALE;
+}
+/**
+ * Convenience wrapper for WS-native numeric fields (1e9-scale).
+ *
+ * - `grossPremiumPerUnit1e9` is WS quote `price`
+ * - `strike1e9` is RFQ/quote strike
+ * - `spotPrice1e9` must be provided for covered_call (from your own spot feed)
+ * - `secondsToExpiry` should be (market.expiry_ts - now)
+ */
+function computeApyFromScaledPrices(args) {
+    return computeApyFromAmounts({
+        positionType: args.positionType,
+        underlyingAmount: args.underlyingAmount,
+        premiumPerUnderlying: scaledPriceToFloat(args.grossPremiumPerUnit1e9),
+        strikePrice: scaledPriceToFloat(args.strike1e9),
+        spotPrice: args.spotPrice1e9 == null ? undefined : scaledPriceToFloat(args.spotPrice1e9),
+        secondsToExpiry: args.secondsToExpiry,
+    });
+}

package/dist/cjs/ws/apy.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apy_1 = require("./apy");
+describe("ws apy helpers", () => {
+    it("matches the intuitive 10 SOL @ $150, $15 premium, 7 days => ~52% APR", () => {
+        const res = (0, apy_1.computeApyFromAmounts)({
+            positionType: "covered_call",
+            underlyingAmount: 10,
+            spotPrice: 150,
+            strikePrice: 150, // not used for calls
+            premiumPerUnderlying: 1.5,
+            secondsToExpiry: 7 * 24 * 60 * 60,
+        });
+        expect(res.premiumNotional).toBeCloseTo(15, 10);
+        expect(res.collateralNotional).toBeCloseTo(1500, 10);
+        expect(res.termYield).toBeCloseTo(0.01, 10);
+        expect(res.apr).toBeCloseTo(0.01 * (365 / 7), 3);
+    });
+    it("scaled wrapper works (1e9 scale)", () => {
+        const res = (0, apy_1.computeApyFromScaledPrices)({
+            positionType: "cash_secured_put",
+            underlyingAmount: 10,
+            grossPremiumPerUnit1e9: 1_500_000_000, // 1.5
+            strike1e9: 150_000_000_000, // 150
+            secondsToExpiry: 7 * 24 * 60 * 60,
+        });
+        expect(res.premiumNotional).toBeCloseTo(15, 10);
+    });
+});

package/dist/cjs/ws/auth.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * WebSocket auth providers.
+ *
+ * RFQ WS auth handshake:
+ * - Server sends `AuthRequest { challenge: <human-readable text> }`
+ * - Client signs UTF-8 bytes of that text and responds:
+ *   `AuthChallenge { challenge, signature: base58(ed25519(utf8(challenge))), pubkey }`
+ *
+ * Source of truth (server):
+ * - rust-backend/rfq-server/src/server/ws.rs
+ * - rust-backend/rfq-server/src/session/handler.rs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomAuthProvider = exports.WalletAuthProvider = exports.KeypairAuthProvider = void 0;
+const addresses_1 = require("@solana/addresses");
+const keys_1 = require("@solana/keys");
+const codecs_strings_1 = require("@solana/codecs-strings");
+const bytesToBase58 = (() => {
+    const dec = (0, codecs_strings_1.getBase58Decoder)();
+    return (bytes) => dec.decode(bytes);
+})();
+const utf8ToBytes = (value) => new TextEncoder().encode(value);
+/**
+ * Auth provider backed by a `CryptoKeyPair`.
+ *
+ */
+class KeypairAuthProvider {
+    address;
+    privateKey;
+    constructor(args) {
+        this.address = args.address;
+        this.privateKey = args.privateKey;
+    }
+    /** Create from a Solana CLI-style 64-byte secret key array (private + public). */
+    static async fromSecretKeyBytes(secretKey64) {
+        const keyPair = await (0, keys_1.createKeyPairFromBytes)(secretKey64);
+        const address = await (0, addresses_1.getAddressFromPublicKey)(keyPair.publicKey);
+        return new KeypairAuthProvider({ address, privateKey: keyPair.privateKey });
+    }
+    /** Create from a 32-byte private key. */
+    static async fromPrivateKeyBytes(privateKey32) {
+        const keyPair = await (0, keys_1.createKeyPairFromPrivateKeyBytes)(privateKey32);
+        const address = await (0, addresses_1.getAddressFromPublicKey)(keyPair.publicKey);
+        return new KeypairAuthProvider({ address, privateKey: keyPair.privateKey });
+    }
+    /** Create from Solana CLI keypair JSON (array of numbers). */
+    static async fromJson(json) {
+        const arr = typeof json === "string" ? JSON.parse(json) : json;
+        return KeypairAuthProvider.fromSecretKeyBytes(Uint8Array.from(arr));
+    }
+    async getPublicKey() {
+        return this.address;
+    }
+    async signChallenge(challenge) {
+        const challengeBytes = utf8ToBytes(challenge);
+        const signatureBytes = await (0, keys_1.signBytes)(this.privateKey, challengeBytes);
+        return bytesToBase58(signatureBytes);
+    }
+}
+exports.KeypairAuthProvider = KeypairAuthProvider;
+/**
+ * Wallet-like provider (browser wallets, custom signers, etc.)
+ *
+ * We intentionally do NOT depend on @solana/web3.js types. Consumers can adapt their wallet
+ * implementation to this minimal interface.
+ */
+class WalletAuthProvider {
+    wallet;
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    async getPublicKey() {
+        const pk = this.wallet.publicKeyBase58 ?? this.wallet.publicKey?.toBase58?.();
+        if (!pk)
+            throw new Error("Wallet not connected (missing public key)");
+        return pk;
+    }
+    async signChallenge(challenge) {
+        const challengeBytes = utf8ToBytes(challenge);
+        // Some wallet APIs expect a mutable `Uint8Array`; codecs return `ReadonlyUint8Array`.
+        const sig = await this.wallet.signMessage(new Uint8Array(challengeBytes));
+        return bytesToBase58(sig);
+    }
+}
+exports.WalletAuthProvider = WalletAuthProvider;
+/**
+ * Custom auth provider for fully custom integrations (hardware wallets, remote signers, etc.).
+ */
+class CustomAuthProvider {
+    getPublicKeyFn;
+    signChallengeFn;
+    constructor(getPublicKey, signChallenge) {
+        this.getPublicKeyFn = getPublicKey;
+        this.signChallengeFn = signChallenge;
+    }
+    async getPublicKey() {
+        return this.getPublicKeyFn();
+    }
+    async signChallenge(challenge) {
+        return this.signChallengeFn(challenge);
+    }
+}
+exports.CustomAuthProvider = CustomAuthProvider;

package/dist/cjs/ws/client.handshake.integration.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+const client_1 = require("./client");
+const wsE2eUrl = process.env.ACTA_WS_E2E_URL;
+const describeIfWsUrl = wsE2eUrl ? describe : describe.skip;
+describeIfWsUrl("ws handshake integration (real backend)", () => {
+    jest.setTimeout(20_000);
+    it("performs Hello -> Welcome without VersionMismatch", async () => {
+        await new Promise((resolve, reject) => {
+            const client = new client_1.ActaWsClient({
+                url: wsE2eUrl,
+                role: "taker",
+                autoReconnect: false,
+                makeSocket: (url) => new ws_1.default(url),
+            });
+            let settled = false;
+            let welcomeReceived = false;
+            const timeout = setTimeout(() => {
+                finish(new Error("Timed out waiting for Welcome"));
+            }, 15_000);
+            const finish = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                try {
+                    client.disconnect();
+                }
+                catch {
+                    // ignore disconnect cleanup errors in tests
+                }
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            };
+            client.on("welcome", (msg) => {
+                try {
+                    expect(msg.protocol_version).toBe("1.0.0");
+                    welcomeReceived = true;
+                    finish();
+                }
+                catch (err) {
+                    finish(err);
+                }
+            });
+            client.on("versionMismatch", (msg) => {
+                finish(new Error(`Unexpected VersionMismatch: requested=${msg.requested_version} server=${msg.server_version} min=${msg.min_supported_version}`));
+            });
+            client.on("error", (err) => {
+                if (!welcomeReceived) {
+                    finish(err);
+                }
+            });
+            client.on("disconnected", (code, reason) => {
+                if (!welcomeReceived) {
+                    finish(new Error(`Disconnected before Welcome (${code} ${reason})`));
+                }
+            });
+            client.connectAnonymous();
+        });
+    });
+});