@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/build/exponentVaults/loopscale-client.js

@@ -1,39 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoopscaleClient = void 0;
+exports.LoopscaleClient = exports.extractCreatedStrategyNonce = exports.extractCreatedStrategyAddress = exports.getLoopscaleTransactionResponses = exports.deserializeLoopscaleTransactionBatchResponse = exports.deserializeLoopscaleTransactionResponse = exports.identifyLoopscaleInstruction = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const policyBuilders_1 = require("./policyBuilders");
-const vault_interaction_1 = require("./vault-interaction");
-// ============================================================================
-// Constants
-// ============================================================================
 const LOOPSCALE_API_BASE_URL = "https://tars.loopscale.com/v1";
-const BS_AUTH = new web3_js_1.PublicKey("CyNKPfqsSLAejjZtEeNG3pR4SkPhSPHXdGhuNTyudrNs");
-const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
-const DISCRIMINATOR_HEX_TO_NAME = new Map(Object.entries(policyBuilders_1.LOOPSCALE_DISCRIMINATORS).map(([name, buf]) => [
-    Buffer.from(buf).toString("hex"),
+const DISCRIMINATOR_HEX_TO_NAME = new Map(Object.entries(policyBuilders_1.LOOPSCALE_DISCRIMINATORS).map(([name, discriminator]) => [
+    Buffer.from(discriminator).toString("hex"),
     name,
 ]));
-const NAME_TO_ACTION_WRAPPER = {
-    createLoan: (ix) => vault_interaction_1.loopscaleAction.createLoan({ instruction: ix }),
-    depositCollateral: (ix) => vault_interaction_1.loopscaleAction.depositCollateral({ instruction: ix }),
-    borrowPrincipal: (ix) => vault_interaction_1.loopscaleAction.borrowPrincipal({ instruction: ix }),
-    repayPrincipal: (ix) => vault_interaction_1.loopscaleAction.repayPrincipal({ instruction: ix }),
-    withdrawCollateral: (ix) => vault_interaction_1.loopscaleAction.withdrawCollateral({ instruction: ix }),
-    closeLoan: (ix) => vault_interaction_1.loopscaleAction.closeLoan({ instruction: ix }),
-    updateWeightMatrix: (ix) => vault_interaction_1.loopscaleAction.updateWeightMatrix({ instruction: ix }),
-    createStrategy: (ix) => vault_interaction_1.loopscaleAction.createStrategy({ instruction: ix }),
-    depositStrategy: (ix) => vault_interaction_1.loopscaleAction.depositStrategy({ instruction: ix }),
-    withdrawStrategy: (ix) => vault_interaction_1.loopscaleAction.withdrawStrategy({ instruction: ix }),
-    closeStrategy: (ix) => vault_interaction_1.loopscaleAction.closeStrategy({ instruction: ix }),
-    updateStrategy: (ix) => vault_interaction_1.loopscaleAction.updateStrategy({ instruction: ix }),
-    lockLoan: (ix) => vault_interaction_1.loopscaleAction.lockLoan({ instruction: ix }),
-    unlockLoan: (ix) => vault_interaction_1.loopscaleAction.unlockLoan({ instruction: ix }),
-    refinanceLedger: (ix) => vault_interaction_1.loopscaleAction.refinanceLedger({ instruction: ix }),
-};
-// ============================================================================
-// Internal helpers
-// ============================================================================
 function toBase58(value) {
     return typeof value === "string" ? value : value.toBase58();
 }
@@ -42,211 +16,181 @@ function toSafeNumber(value, field) {
         if (value < 0n)
             throw new Error(`${field} must be non-negative`);
         if (value > BigInt(Number.MAX_SAFE_INTEGER))
-            throw new Error(`${field} too large for JSON integer`);
+            throw new Error(`${field} is too large for a JSON number`);
         return Number(value);
     }
-    if (!Number.isInteger(value) || value < 0)
+    if (!Number.isInteger(value) || value < 0) {
         throw new Error(`${field} must be a non-negative integer`);
+    }
     return value;
 }
-function isEmptySignature(sig) {
-    return sig.every((b) => b === 0);
+function hasSignature(signature) {
+    return signature.some((value) => value !== 0);
 }
-function identifyInstruction(ix) {
-    if (!ix.programId.equals(policyBuilders_1.LOOPSCALE_PROGRAM_ID))
-        return null;
-    const hex = Buffer.from(ix.data).subarray(0, 8).toString("hex");
-    return DISCRIMINATOR_HEX_TO_NAME.get(hex) ?? null;
+function withPayerHeader(headers, payer) {
+    if (!payer)
+        return headers;
+    return { ...headers, payer };
+}
+function buildTransactionFromResponse(response) {
+    const message = web3_js_1.VersionedMessage.deserialize(Buffer.from(response.message, "base64"));
+    const transaction = new web3_js_1.VersionedTransaction(message);
+    const signerKeys = message.staticAccountKeys.slice(0, message.header.numRequiredSignatures);
+    for (const signature of response.signatures) {
+        const signer = new web3_js_1.PublicKey(signature.publicKey);
+        const bytes = Buffer.from(signature.signature, "base64");
+        if (bytes.length !== 64) {
+            throw new Error(`Invalid signature for ${signature.publicKey}`);
+        }
+        const signerIndex = signerKeys.findIndex((candidate) => candidate.equals(signer));
+        if (signerIndex >= 0) {
+            transaction.signatures[signerIndex] = new Uint8Array(bytes);
+        }
+    }
+    return transaction;
+}
+function mergeCoSignedTransaction(transaction, coSignedTransaction) {
+    const left = Buffer.from(transaction.message.serialize());
+    const right = Buffer.from(coSignedTransaction.message.serialize());
+    if (!left.equals(right)) {
+        throw new Error("Loopscale returned a different transaction message; refusing to merge signatures");
+    }
+    const signerKeys = coSignedTransaction.message.staticAccountKeys
+        .slice(0, coSignedTransaction.message.header.numRequiredSignatures);
+    const inputSignerKeys = transaction.message.staticAccountKeys
+        .slice(0, transaction.message.header.numRequiredSignatures);
+    for (let index = 0; index < inputSignerKeys.length; index += 1) {
+        const inputSignature = transaction.signatures[index];
+        if (!hasSignature(inputSignature))
+            continue;
+        const signerIndex = signerKeys.findIndex((candidate) => candidate.equals(inputSignerKeys[index]));
+        if (signerIndex >= 0 && !hasSignature(coSignedTransaction.signatures[signerIndex])) {
+            coSignedTransaction.signatures[signerIndex] = inputSignature;
+        }
+    }
+    return coSignedTransaction;
 }
-async function decompileInstructions(connection, transaction) {
-    const lookupTableAccounts = await Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
+async function resolveAddressLookupTables(connection, transaction) {
+    return Promise.all(transaction.message.addressTableLookups.map(async (lookup) => {
         const result = await connection.getAddressLookupTable(lookup.accountKey);
         if (!result.value) {
             throw new Error(`Missing lookup table ${lookup.accountKey.toBase58()}`);
         }
         return result.value;
     }));
-    return web3_js_1.TransactionMessage.decompile(transaction.message, { addressLookupTableAccounts: lookupTableAccounts }).instructions;
 }
-function buildTxFromLegacyEntry(entry) {
-    const message = web3_js_1.VersionedMessage.deserialize(Buffer.from(entry.message, "base64"));
-    const tx = new web3_js_1.VersionedTransaction(message);
-    const signerKeys = message.staticAccountKeys.slice(0, message.header.numRequiredSignatures);
-    for (const sig of entry.signatures) {
-        const pubkey = new web3_js_1.PublicKey(sig.publicKey);
-        const sigBytes = Buffer.from(sig.signature, "base64");
-        if (sigBytes.length !== 64)
-            throw new Error(`Invalid signature for ${pubkey.toBase58()}`);
-        const idx = signerKeys.findIndex((k) => k.equals(pubkey));
-        if (idx >= 0)
-            tx.signatures[idx] = new Uint8Array(sigBytes);
+async function findInstructionByName(connection, transactions, name) {
+    for (const transaction of transactions) {
+        const addressLookupTableAccounts = await resolveAddressLookupTables(connection, transaction);
+        const instructions = web3_js_1.TransactionMessage.decompile(transaction.message, { addressLookupTableAccounts }).instructions;
+        const match = instructions.find((instruction) => identifyLoopscaleInstruction(instruction) === name);
+        if (match) {
+            return match;
+        }
     }
-    return tx;
+    return null;
 }
-function mergeInputSignatures(resultTx, inputTx) {
-    const signerKeys = resultTx.message.staticAccountKeys.slice(0, resultTx.message.header.numRequiredSignatures);
-    const inputKeys = inputTx.message.staticAccountKeys;
-    const inputNumSigners = inputTx.message.header.numRequiredSignatures;
-    for (let i = 0; i < inputNumSigners; i++) {
-        const inputSig = inputTx.signatures[i];
-        if (isEmptySignature(inputSig))
-            continue;
-        const resultIdx = signerKeys.findIndex((key) => key.equals(inputKeys[i]));
-        if (resultIdx < 0)
-            continue;
-        if (isEmptySignature(resultTx.signatures[resultIdx])) {
-            resultTx.signatures[resultIdx] = inputSig;
-        }
+/**
+ * Identify a Loopscale strategy or loan instruction from its discriminator.
+ *
+ * Returns `null` for non-Loopscale instructions and for unsupported Loopscale
+ * instructions outside the strategies + loans scope of this SDK module.
+ */
+function identifyLoopscaleInstruction(instruction) {
+    if (!instruction.programId.equals(policyBuilders_1.LOOPSCALE_PROGRAM_ID)) {
+        return null;
     }
-    return resultTx;
+    const discriminator = Buffer.from(instruction.data).subarray(0, 8).toString("hex");
+    return DISCRIMINATOR_HEX_TO_NAME.get(discriminator) ?? null;
+}
+exports.identifyLoopscaleInstruction = identifyLoopscaleInstruction;
+/**
+ * Deserialize a raw Loopscale transaction response into a `VersionedTransaction`.
+ */
+function deserializeLoopscaleTransactionResponse(response) {
+    return buildTransactionFromResponse(response);
+}
+exports.deserializeLoopscaleTransactionResponse = deserializeLoopscaleTransactionResponse;
+/**
+ * Deserialize a raw Loopscale transaction batch response into `VersionedTransaction`s.
+ */
+function deserializeLoopscaleTransactionBatchResponse(response) {
+    return response.map((entry) => deserializeLoopscaleTransactionResponse(entry));
 }
-function ensureMessageMatches(a, b) {
-    const am = Buffer.from(a.message.serialize());
-    const bm = Buffer.from(b.message.serialize());
-    if (!am.equals(bm)) {
-        throw new Error("Loopscale returned a different transaction message; refusing to merge");
+exports.deserializeLoopscaleTransactionBatchResponse = deserializeLoopscaleTransactionBatchResponse;
+/**
+ * Extract the raw transaction responses from any supported Loopscale transaction response shape.
+ */
+function getLoopscaleTransactionResponses(response) {
+    if (Array.isArray(response)) {
+        return response;
+    }
+    if ("transactions" in response) {
+        return response.transactions;
+    }
+    if ("transaction" in response) {
+        return [response.transaction];
     }
+    return [response];
 }
-// ============================================================================
-// LoopscaleClient
-// ============================================================================
+exports.getLoopscaleTransactionResponses = getLoopscaleTransactionResponses;
+/**
+ * Extract the strategy PDA created by a Loopscale `createStrategy` response.
+ */
+async function extractCreatedStrategyAddress(connection, response) {
+    const transactions = getLoopscaleTransactionResponses(response)
+        .map((entry) => deserializeLoopscaleTransactionResponse(entry));
+    const instruction = await findInstructionByName(connection, transactions, "createStrategy");
+    const strategy = instruction?.keys[3]?.pubkey;
+    if (!strategy) {
+        throw new Error("Loopscale createStrategy response did not contain a createStrategy instruction");
+    }
+    return strategy;
+}
+exports.extractCreatedStrategyAddress = extractCreatedStrategyAddress;
+/**
+ * Extract the nonce public key used by a Loopscale `createStrategy` response.
+ */
+async function extractCreatedStrategyNonce(connection, response) {
+    const transactions = getLoopscaleTransactionResponses(response)
+        .map((entry) => deserializeLoopscaleTransactionResponse(entry));
+    const instruction = await findInstructionByName(connection, transactions, "createStrategy");
+    const nonce = instruction?.keys[2]?.pubkey;
+    if (!nonce) {
+        throw new Error("Loopscale createStrategy response did not contain the strategy nonce account");
+    }
+    return nonce;
+}
+exports.extractCreatedStrategyNonce = extractCreatedStrategyNonce;
+/**
+ * Thin docs-aligned Loopscale client for strategies, loans, and related query endpoints.
+ *
+ * Transaction methods intentionally return the raw Loopscale response shapes
+ * instead of derived sync-action bundles. Use the execution helpers from
+ * `loopscale-execution.ts` when you need to turn a raw response into Exponent
+ * transaction steps.
+ *
+ * Loan-lock endpoints such as repay, close, and refinance are intentionally
+ * excluded from this client. Loopscale documents those responses separately,
+ * but the returned lock/unlock flows are not compatible with the Exponent CPI
+ * execution path this SDK is designed around.
+ */
 class LoopscaleClient {
     connection;
     baseUrl;
     userWallet;
-    bsAuth;
-    useMpcCoSign;
+    payer;
     debug;
-    vaultCtx = null;
     constructor(config) {
         this.connection = config.connection;
         this.baseUrl = config.baseUrl ?? LOOPSCALE_API_BASE_URL;
         this.userWallet = toBase58(config.userWallet);
-        this.bsAuth = config.bsAuth ?? BS_AUTH;
-        this.useMpcCoSign = config.useMpcCoSign ?? true;
+        this.payer = toBase58(config.payer ?? config.userWallet);
         this.debug = config.debug ?? false;
     }
-    // ── Vault execution context ──
-    setVaultContext(ctx) {
-        this.vaultCtx = ctx;
-    }
-    requireVaultContext() {
-        if (!this.vaultCtx) {
-            throw new Error("LoopscaleClient: call setVaultContext() before executeBatches/executeSyncTx");
-        }
-        return this.vaultCtx;
-    }
-    async executeBatches(batches) {
-        const ctx = this.requireVaultContext();
-        const commitment = ctx.commitment ?? "confirmed";
-        const results = [];
-        for (const [batchIndex, batch] of batches.entries()) {
-            const result = batch.syncActions.length === 0
-                ? await this.executePrebuiltBatch(batch, batchIndex, commitment)
-                : await this.executeSyncBatch(batch, batchIndex, ctx, commitment);
-            results.push(result);
-            if (result.error) {
-                return { error: result.error, results };
-            }
-        }
-        return { error: null, results };
-    }
-    async executeSyncTx(syncActions) {
-        const ctx = this.requireVaultContext();
-        const commitment = ctx.commitment ?? "confirmed";
-        return this.executeSyncBatch({ syncActions, topLevelInstructions: [], setupInstructions: [] }, 0, ctx, commitment);
-    }
-    async executePrebuiltBatch(batch, batchIndex, commitment) {
-        const ctx = this.requireVaultContext();
-        const tx = batch.raw.transaction;
-        const signerKeys = tx.message.staticAccountKeys.slice(0, tx.message.header.numRequiredSignatures);
-        const available = new Map(ctx.signers.map((s) => [s.publicKey.toBase58(), s]));
-        const local = signerKeys.map((k) => available.get(k.toBase58())).filter((s) => Boolean(s));
-        if (local.length > 0)
-            tx.sign(local);
-        const missing = signerKeys.filter((_, i) => tx.signatures[i]?.every((b) => b === 0));
-        if (missing.length > 0) {
-            throw new Error(`batch ${batchIndex + 1}: missing signer(s): ${missing.map((k) => k.toBase58()).join(", ")}`);
-        }
-        return { batchIndex, ...(await this.sendAndConfirm(tx, ctx.sendOptions, { commitment })) };
-    }
-    async executeSyncBatch(batch, batchIndex, ctx, commitment) {
-        const syncResult = await (0, vault_interaction_1.createVaultSyncTransaction)({
-            instructions: batch.syncActions,
-            owner: ctx.owner,
-            connection: this.connection,
-            policyPda: ctx.policyPda,
-            vaultPda: ctx.vaultPda,
-            signer: ctx.signer,
-            accountIndex: ctx.accountIndex,
-            constraintIndices: ctx.constraintIndices,
-            vaultAddress: ctx.vaultAddress,
-            leadingAccounts: ctx.leadingAccounts,
-            preHookAccounts: ctx.preHookAccounts,
-            postHookAccounts: ctx.postHookAccounts,
-            squadsProgram: ctx.squadsProgram,
-        });
-        if (syncResult.setupInstructions.length > 0) {
-            throw new Error(`batch ${batchIndex + 1}: unexpected sync setupInstructions (${syncResult.setupInstructions.length})`);
-        }
-        const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash(commitment);
-        const msg = new web3_js_1.TransactionMessage({
-            payerKey: ctx.signers[0].publicKey,
-            recentBlockhash: blockhash,
-            instructions: [
-                ...(ctx.prependInstructions ?? []),
-                ...batch.topLevelInstructions,
-                ...syncResult.preInstructions,
-                syncResult.instruction,
-                ...syncResult.postInstructions,
-            ],
-        }).compileToV0Message(ctx.addressLookupTableAccounts ?? []);
-        let tx = new web3_js_1.VersionedTransaction(msg);
-        tx.sign([...ctx.signers, ...syncResult.signers]);
-        tx = await this.coSign(tx);
-        return {
-            batchIndex,
-            ...(await this.sendAndConfirm(tx, ctx.sendOptions, { commitment, blockhash, lastValidBlockHeight })),
-        };
-    }
-    async sendAndConfirm(tx, sendOptions, confirmation) {
-        const signature = await this.connection.sendTransaction(tx, sendOptions);
-        if (confirmation.blockhash && confirmation.lastValidBlockHeight !== undefined) {
-            try {
-                await this.connection.confirmTransaction({
-                    signature,
-                    blockhash: confirmation.blockhash,
-                    lastValidBlockHeight: confirmation.lastValidBlockHeight,
-                }, confirmation.commitment);
-            }
-            catch (err) {
-                if (this.debug)
-                    console.warn(`[LoopscaleClient] confirmTransaction failed for ${signature}:`, err);
-            }
-        }
-        else {
-            for (let attempt = 0; attempt < 60; attempt += 1) {
-                const statuses = await this.connection.getSignatureStatuses([signature]);
-                const s = statuses.value[0];
-                if (s?.err || s?.confirmationStatus === "confirmed" || s?.confirmationStatus === "finalized")
-                    break;
-                await new Promise((r) => setTimeout(r, 1_000));
-            }
-        }
-        const finality = confirmation.commitment === "finalized" ? "finalized" : "confirmed";
-        for (let attempt = 0; attempt < 20; attempt += 1) {
-            const txResult = await this.connection.getTransaction(signature, {
-                commitment: finality,
-                maxSupportedTransactionVersion: 0,
-            });
-            if (txResult) {
-                return { signature, logs: txResult.meta?.logMessages ?? null, error: txResult.meta?.err ?? null };
-            }
-            await new Promise((r) => setTimeout(r, 500));
-        }
-        return { signature, logs: null, error: `Transaction ${signature} not found after confirmation timeout` };
-    }
-    // ── Data ──
+    /**
+     * Load Loopscale quotes for a principal/collateral pair.
+     */
     async getQuotes(params) {
         const body = {
             durationType: params.durationType,
@@ -256,47 +200,48 @@ class LoopscaleClient {
             limit: params.limit ?? 10,
             offset: params.offset ?? 0,
         };
-        return this.post("/markets/quote", body, { "user-wallet": this.userWallet });
+        if (params.minPrincipalAmount !== undefined) {
+            body.minPrincipalAmount = toSafeNumber(params.minPrincipalAmount, "minPrincipalAmount");
+        }
+        return this.post("/markets/quote", body, {
+            "user-wallet": this.userWallet,
+        });
     }
+    /**
+     * Load the best quote for one or more specific collateral assets.
+     */
     async getMaxQuote(params) {
-        const body = {
+        return this.post("/markets/quote/max", {
             durationType: params.durationType,
             duration: params.duration,
             principalMint: toBase58(params.principalMint),
-            collateralFilter: params.collateralFilter.map((f) => ({
-                amount: toSafeNumber(f.amount, "amount"),
-                assetData: f.assetData,
+            collateralFilter: params.collateralFilter.map((item) => ({
+                amount: toSafeNumber(item.amount, "amount"),
+                assetData: item.assetData,
             })),
-        };
-        return this.post("/markets/quote/max", body, { "user-wallet": this.userWallet });
+        }, {
+            "user-wallet": this.userWallet,
+        });
     }
+    /**
+     * Load Loopscale loan positions.
+     */
     async getLoanInfo(params) {
-        return this.post("/markets/loans/info", params, { "user-wallet": this.userWallet });
+        return this.post("/markets/loans/info", params);
     }
+    /**
+     * Load Loopscale lending strategies.
+     */
     async getStrategies(params) {
-        return this.post("/markets/strategy/infos", params, { "user-wallet": this.userWallet });
-    }
-    async getCollateralHolders(params) {
-        return this.post("/markets/collateral/holders", params);
+        return this.post("/markets/strategy/infos", params);
     }
-    async getHistoricalCollateralHolders(params) {
-        return this.post("/markets/collateral/holders/historical", params);
-    }
-    async getVaultDepositors(params) {
-        return this.post("/markets/lending_vaults/deposits", params);
-    }
-    async getVaultInfo(params) {
-        return this.post("/markets/lending_vaults/info", params);
-    }
-    async getLoopInfo(params) {
-        return this.post("/markets/loop/info", params);
-    }
-    // ── Strategy (LENDER side) ──
+    /**
+     * Build a raw Loopscale `createStrategy` transaction batch.
+     */
     async createStrategy(params) {
-        const lender = toBase58(params.lender);
         const body = {
             principalMint: toBase58(params.principalMint),
-            lender,
+            lender: toBase58(params.lender),
             amount: toSafeNumber(params.amount, "amount"),
         };
         if (params.originationsEnabled !== undefined)
@@ -315,180 +260,69 @@ class LoopscaleClient {
             body.marketInformation = toBase58(params.marketInformation);
         if (params.externalYieldSourceArgs)
             body.externalYieldSourceArgs = params.externalYieldSourceArgs;
-        const entries = await this.post("/markets/strategy/create", body, { payer: this.userWallet });
-        if (!Array.isArray(entries) || entries.length === 0) {
-            throw new Error("Loopscale strategy/create returned no transactions");
-        }
-        const batches = await this.parseStrategyBatches(entries);
-        const createBatch = batches.find((batch) => batch.raw.loopscaleInstructions.some((g) => g.name === "createStrategy"));
-        const createIx = createBatch?.raw.loopscaleInstructions.find((g) => g.name === "createStrategy");
-        if (!createIx)
-            throw new Error("Loopscale strategy/create did not return a createStrategy instruction");
-        const strategyAddress = createIx.instruction.keys[3]?.pubkey;
-        const noncePublicKey = createIx.instruction.keys[2]?.pubkey;
-        if (!strategyAddress || !noncePublicKey) {
-            throw new Error("Invalid createStrategy account layout from API");
-        }
-        if (this.debug) {
-            console.log(`[LoopscaleClient] createStrategy: strategy=${strategyAddress.toBase58()}, batches=${batches.length}`);
-        }
-        return { batches, strategyAddress, noncePublicKey };
+        return this.post("/markets/strategy/create", body, { payer: this.payer });
     }
+    /**
+     * Build a raw Loopscale `depositStrategy` transaction.
+     */
     async depositStrategy(params) {
-        const body = {
+        return this.post("/markets/strategy/deposit", {
             strategy: toBase58(params.strategy),
             amount: toSafeNumber(params.amount, "amount"),
-        };
-        return this.fetchAndClassifySingleTx("/markets/strategy/deposit", body, {
+        }, withPayerHeader({
             "User-Wallet": this.userWallet,
-            payer: this.userWallet,
-        });
+        }, this.payer));
     }
+    /**
+     * Build a raw Loopscale `withdrawStrategy` transaction.
+     */
     async withdrawStrategy(params) {
-        const body = {
+        return this.post("/markets/strategy/withdraw", {
             strategy: toBase58(params.strategy),
             amount: toSafeNumber(params.amount, "amount"),
             withdrawAll: params.withdrawAll,
-        };
-        return this.fetchAndClassifySingleTx("/markets/strategy/withdraw", body, {
+        }, withPayerHeader({
             "User-Wallet": this.userWallet,
-            payer: this.userWallet,
-        });
+        }, this.payer));
     }
+    /**
+     * Build a raw Loopscale `closeStrategy` transaction.
+     */
     async closeStrategy(params) {
-        const strategy = toBase58(params.strategy);
-        return this.fetchAndClassifySingleTx(`/markets/strategy/close/${strategy}`, undefined, {
-            payer: this.userWallet,
-        });
+        return this.post(`/markets/strategy/close/${toBase58(params.strategy)}`, undefined, { payer: this.payer });
     }
+    /**
+     * Build raw Loopscale `updateStrategy` transactions.
+     */
     async updateStrategy(params) {
-        const body = { strategy: toBase58(params.strategy) };
+        const body = {
+            strategy: toBase58(params.strategy),
+        };
         if (params.collateralTerms)
             body.collateralTerms = params.collateralTerms;
         if (params.updateParams)
             body.updateParams = params.updateParams;
-        const entries = await this.post("/markets/strategy/update", body, { "User-Wallet": this.userWallet, payer: this.userWallet });
-        if (!Array.isArray(entries) || entries.length === 0) {
-            throw new Error("Loopscale strategy/update returned no transactions");
-        }
-        const batches = await this.parseStrategyBatches(entries);
-        if (this.debug) {
-            console.log(`[LoopscaleClient] updateStrategy: batches=${batches.length}`);
-        }
-        return { batches };
-    }
-    // ── Loan (BORROWER side) ──
-    /**
-     * Build a standalone borrow_principal instruction (no lock/unlock needed).
-     * Requires collateral to already be deposited in the loan.
-     */
-    buildBorrowPrincipalInstruction(params) {
-        const borrower = new web3_js_1.PublicKey(toBase58(params.borrower));
-        const loan = new web3_js_1.PublicKey(toBase58(params.loan));
-        const strategy = new web3_js_1.PublicKey(toBase58(params.strategy));
-        const marketInformation = new web3_js_1.PublicKey(toBase58(params.marketInformation));
-        const principalMint = new web3_js_1.PublicKey(toBase58(params.principalMint));
-        const amount = typeof params.amount === "bigint" ? params.amount : BigInt(params.amount);
-        const guidance = params.assetIndexGuidance;
-        const duration = params.durationIndex;
-        const expectedApy = params.expectedApy !== undefined
-            ? (typeof params.expectedApy === "bigint" ? params.expectedApy : BigInt(params.expectedApy))
-            : 0n;
-        const expectedLqt = params.expectedLqt ?? [0, 0, 0, 0, 0];
-        const skipSolUnwrap = params.skipSolUnwrap ?? false;
-        // Serialize instruction data: discriminator + amount + guidance_vec + duration + expected_loan_values + skip_sol_unwrap
-        const dataSize = 8 + 8 + 4 + guidance.length + 1 + 8 + 20 + 1;
-        const data = Buffer.alloc(dataSize);
-        let offset = 0;
-        Buffer.from(policyBuilders_1.LOOPSCALE_DISCRIMINATORS.borrowPrincipal).copy(data, 0);
-        offset += 8;
-        data.writeBigUInt64LE(amount, offset);
-        offset += 8;
-        data.writeUInt32LE(guidance.length, offset);
-        offset += 4;
-        for (const b of guidance) {
-            data.writeUInt8(b, offset);
-            offset += 1;
-        }
-        data.writeUInt8(duration, offset);
-        offset += 1;
-        data.writeBigUInt64LE(expectedApy, offset);
-        offset += 8;
-        for (let i = 0; i < 5; i++) {
-            data.writeUInt32LE(expectedLqt[i] ?? 0, offset);
-            offset += 4;
-        }
-        data.writeUInt8(skipSolUnwrap ? 1 : 0, offset);
-        offset += 1;
-        const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-        const [borrowerTa] = web3_js_1.PublicKey.findProgramAddressSync([borrower.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), principalMint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID);
-        const [strategyTa] = web3_js_1.PublicKey.findProgramAddressSync([strategy.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), principalMint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID);
-        const eventAuthority = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], policyBuilders_1.LOOPSCALE_PROGRAM_ID)[0];
-        const ix = new web3_js_1.TransactionInstruction({
-            programId: policyBuilders_1.LOOPSCALE_PROGRAM_ID,
-            keys: [
-                { pubkey: this.bsAuth, isSigner: true, isWritable: false },
-                { pubkey: borrower, isSigner: true, isWritable: true },
-                { pubkey: borrower, isSigner: true, isWritable: false },
-                { pubkey: loan, isSigner: false, isWritable: true },
-                { pubkey: strategy, isSigner: false, isWritable: true },
-                { pubkey: marketInformation, isSigner: false, isWritable: true },
-                { pubkey: principalMint, isSigner: false, isWritable: false },
-                { pubkey: borrowerTa, isSigner: false, isWritable: true },
-                { pubkey: strategyTa, isSigner: false, isWritable: true },
-                { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-                { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
-                { pubkey: eventAuthority, isSigner: false, isWritable: false },
-                { pubkey: policyBuilders_1.LOOPSCALE_PROGRAM_ID, isSigner: false, isWritable: false },
-                ...params.healthCheckAccounts,
-            ],
-            data,
-        });
-        return ix;
+        return this.post("/markets/strategy/update", body, withPayerHeader({
+            "User-Wallet": this.userWallet,
+        }, this.payer));
     }
     /**
-     * Build a standalone borrow_principal wrapped as a LoopscaleInstruction for sync tx.
-     * Requires collateral to already be deposited in the loan.
+     * Build a raw Loopscale `createLoan` transaction.
      */
-    buildBorrowPrincipalAction(params) {
-        return vault_interaction_1.loopscaleAction.borrowPrincipal({ instruction: this.buildBorrowPrincipalInstruction(params) });
-    }
-    async repayLoan(params) {
-        const body = {
-            loan: toBase58(params.loan),
-            repayParams: params.repayParams.map((p) => ({
-                amount: toSafeNumber(p.amount, "repayAmount"),
-                ledgerIndex: p.ledgerIndex,
-                repayAll: p.repayAll,
-            })),
-            collateralWithdrawalParams: (params.collateralWithdrawalParams ?? []).map((p) => ({
-                amount: toSafeNumber(p.amount, "withdrawAmount"),
-                collateralMint: toBase58(p.collateralMint),
-            })),
-        };
-        if (params.closeIfPossible !== undefined)
-            body.closeIfPossible = params.closeIfPossible;
-        return this.fetchAndClassifyWrappedTx("/markets/creditbook/repay", body, { "user-wallet": this.userWallet });
-    }
-    async closeLoan(params) {
-        const body = { loan: toBase58(params.loan) };
-        return this.fetchAndClassifyWrappedTx("/markets/creditbook/close_loan", body, { "user-wallet": this.userWallet });
-    }
     async createLoan(params) {
         const body = {
             borrower: toBase58(params.borrower),
-            depositCollateral: params.depositCollateral.map((c) => ({
-                collateralAmount: toSafeNumber(c.collateralAmount, "collateralAmount"),
-                collateralAssetData: c.collateralAssetData,
+            depositCollateral: params.depositCollateral.map((item) => ({
+                collateralAmount: toSafeNumber(item.collateralAmount, "collateralAmount"),
+                collateralAssetData: item.collateralAssetData,
             })),
-            principalRequested: params.principalRequested.map((p) => ({
-                ledgerIndex: p.ledgerIndex,
-                principalAmount: toSafeNumber(p.principalAmount, "principalAmount"),
-                principalMint: toBase58(p.principalMint),
-                strategy: toBase58(p.strategy),
-                durationIndex: p.durationIndex,
-                expectedLoanValues: p.expectedLoanValues ?? { expectedApy: 0, expectedLqt: [0, 0, 0, 0, 0] },
+            principalRequested: params.principalRequested.map((item) => ({
+                ledgerIndex: item.ledgerIndex,
+                principalAmount: toSafeNumber(item.principalAmount, "principalAmount"),
+                principalMint: toBase58(item.principalMint),
+                strategy: toBase58(item.strategy),
+                durationIndex: item.durationIndex,
+                expectedLoanValues: item.expectedLoanValues ?? { expectedApy: 0, expectedLqt: [0, 0, 0, 0, 0] },
             })),
         };
         if (params.assetIndexGuidance)
@@ -497,38 +331,40 @@ class LoopscaleClient {
             body.loanNonce = params.loanNonce;
         if (params.isLoop !== undefined)
             body.isLoop = params.isLoop;
-        const headers = { payer: this.userWallet };
-        const data = await this.post("/markets/creditbook/create", body, headers);
-        const tx = buildTxFromLegacyEntry(data.transaction);
-        const instructions = await decompileInstructions(this.connection, tx);
-        const classified = this.classifyInstructions(instructions);
-        const syncActions = this.buildSyncActions(classified.loopscale);
-        const raw = this.buildRawBundle(tx, instructions, classified.loopscale);
-        const loanAddress = new web3_js_1.PublicKey(data.loanAddress);
-        if (this.debug) {
-            console.log(`[LoopscaleClient] createLoan: loan=${loanAddress.toBase58()}, syncActions=${syncActions.length}`);
-        }
-        return { syncActions, topLevelInstructions: classified.topLevel, raw, loanAddress };
+        return this.post("/markets/creditbook/create", body, { payer: this.payer });
     }
-    async apiBorrowPrincipal(params) {
-        const borrowParams = {
-            amount: toSafeNumber(params.borrowParams.amount, "amount"),
-            duration: params.borrowParams.durationIndex,
-        };
-        if (params.borrowParams.expectedLoanValues) {
-            borrowParams.expectedLoanValues = params.borrowParams.expectedLoanValues;
-        }
+    /**
+     * Build a raw Loopscale `borrowPrincipal` transaction.
+     *
+     * The published OpenAPI schema currently documents a single serialized
+     * transaction response, but live responses can also return a wrapped
+     * `transactions` array with `expectedLoanInfo` when Loopscale inserts
+     * additional internal maintenance steps.
+     */
+    async borrowPrincipal(params) {
         const body = {
             loan: toBase58(params.loan),
-            borrowParams,
+            borrowParams: {
+                amount: toSafeNumber(params.borrowParams.amount, "amount"),
+                duration: params.borrowParams.durationIndex,
+            },
             strategy: toBase58(params.strategy),
         };
+        if (params.borrowParams.expectedLoanValues) {
+            body.borrowParams = {
+                ...body.borrowParams,
+                expectedLoanValues: params.borrowParams.expectedLoanValues,
+            };
+        }
         if (params.refinanceParams)
             body.refinanceParams = params.refinanceParams;
         if (params.isLoop !== undefined)
             body.isLoop = params.isLoop;
-        return this.fetchAndClassifySingleTx("/markets/creditbook/borrow", body, { payer: this.userWallet });
+        return this.post("/markets/creditbook/borrow", body, { payer: this.payer });
     }
+    /**
+     * Build a raw Loopscale `depositCollateral` transaction.
+     */
     async depositCollateral(params) {
         const body = {
             loan: toBase58(params.loan),
@@ -541,151 +377,69 @@ class LoopscaleClient {
             body.assetIndexGuidance = params.assetIndexGuidance;
         if (params.expectedLoanValues)
             body.expectedLoanValues = params.expectedLoanValues;
-        return this.fetchAndClassifySingleTx("/markets/creditbook/collateral/deposit", body, {
+        return this.post("/markets/creditbook/collateral/deposit", body, withPayerHeader({
             "user-wallet": this.userWallet,
-            payer: this.userWallet,
-        });
+        }, this.payer));
     }
+    /**
+     * Build a raw Loopscale `withdrawCollateral` transaction.
+     *
+     * Full collateral removal can trigger internal loan-maintenance instructions,
+     * so callers should accept either a single serialized transaction or a wrapped
+     * `transactions` array.
+     */
     async withdrawCollateral(params) {
         const body = {
             loan: toBase58(params.loan),
             collateralMint: toBase58(params.collateralMint),
             amount: toSafeNumber(params.amount, "amount"),
             collateralIndex: params.collateralIndex,
+            expectedLoanValues: params.expectedLoanValues,
         };
-        if (params.expectedLoanValues)
-            body.expectedLoanValues = params.expectedLoanValues;
         if (params.assetIndexGuidance)
             body.assetIndexGuidance = params.assetIndexGuidance;
-        return this.fetchAndClassifySingleTx("/markets/creditbook/collateral/withdraw", body, {
-            "user-wallet": this.userWallet,
-            payer: this.userWallet,
-        });
-    }
-    async refinanceLoan(params) {
-        const body = {
-            loan: toBase58(params.loan),
-            oldStrategy: toBase58(params.oldStrategy),
-            newStrategy: toBase58(params.newStrategy),
-            refinanceParams: params.refinanceParams,
-        };
-        return this.fetchAndClassifyWrappedTx("/markets/creditbook/refinance", body, {
+        return this.post("/markets/creditbook/collateral/withdraw", body, withPayerHeader({
             "user-wallet": this.userWallet,
-        });
+        }, this.payer));
     }
-    // ── Co-signing ──
+    /**
+     * Co-sign a prepared transaction with Loopscale's back-end signer.
+     *
+     * This uses Loopscale's public MPC co-signing endpoint. The returned
+     * transaction is required to keep the exact same message as the locally
+     * signed input, and any local signatures that are missing from the response
+     * are copied back onto the returned transaction before it is handed to the
+     * caller.
+     */
     async coSign(transaction) {
-        const serializedTx = Buffer.from(transaction.serialize()).toString("base64");
-        const serializedMsg = Buffer.from(transaction.message.serialize()).toString("base64");
-        if (this.useMpcCoSign) {
-            const body = {
-                batches: [{
-                        transactions: [{
-                                identifier: "loopscale-cosign",
-                                transaction: serializedTx,
-                                transactionType: 1,
-                            }],
-                    }],
-            };
-            const data = await this.post("/mpc/txns/gen", body);
-            const txEntry = data.batches?.[0]?.transactions?.[0];
-            if (!txEntry)
-                throw new Error("Loopscale MPC co-signing returned no transaction");
-            const resultTx = web3_js_1.VersionedTransaction.deserialize(Buffer.from(txEntry.transaction, "base64"));
-            ensureMessageMatches(resultTx, transaction);
-            return mergeInputSignatures(resultTx, transaction);
-        }
-        // Legacy endpoint
-        const body = [{ transaction: serializedTx, message: serializedMsg }];
-        const entries = await this.post("/markets/txn/gen", body, { "user-wallet": this.userWallet });
-        if (!entries?.[0])
-            throw new Error("Loopscale co-signing returned no entries");
-        const resultTx = buildTxFromLegacyEntry(entries[0]);
-        ensureMessageMatches(resultTx, transaction);
-        return mergeInputSignatures(resultTx, transaction);
-    }
-    // ── Instruction helpers ──
-    classifyInstructions(instructions) {
-        const loopscale = [];
-        const topLevel = [];
-        const setup = [];
-        for (const ix of instructions) {
-            if (ix.programId.equals(policyBuilders_1.LOOPSCALE_PROGRAM_ID)) {
-                loopscale.push({ name: identifyInstruction(ix), instruction: ix });
-            }
-            else if (ix.programId.equals(web3_js_1.ComputeBudgetProgram.programId)) {
-                topLevel.push(ix);
-            }
-            else if (ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-                setup.push(ix);
-            }
-            else {
-                // Oracle feeds, system program, etc. — top level
-                topLevel.push(ix);
-            }
-        }
-        return { loopscale, topLevel, setup };
-    }
-    static identifyInstruction(ix) {
-        return identifyInstruction(ix);
-    }
-    // ── Private helpers ──
-    buildSyncActions(loopscaleIxs) {
-        return loopscaleIxs
-            .filter((g) => g.name !== null)
-            .map((g) => {
-            const wrapper = NAME_TO_ACTION_WRAPPER[g.name];
-            return wrapper(g.instruction);
+        const serializedTransaction = Buffer.from(transaction.serialize()).toString("base64");
+        const data = await this.post("/mpc/txns/gen", {
+            batches: [{
+                    transactions: [{
+                            identifier: "loopscale-cosign",
+                            transaction: serializedTransaction,
+                            transactionType: 1,
+                        }],
+                }],
         });
-    }
-    buildRawBundle(transaction, instructions, loopscaleInstructions) {
-        return { transaction, instructions, loopscaleInstructions };
-    }
-    toSingleTxResult(batch) {
-        return {
-            syncActions: batch.syncActions,
-            topLevelInstructions: batch.topLevelInstructions,
-            raw: batch.raw,
-        };
-    }
-    async parseTransactionEntry(entry) {
-        const tx = buildTxFromLegacyEntry(entry);
-        const instructions = await decompileInstructions(this.connection, tx);
-        const classified = this.classifyInstructions(instructions);
-        const syncActions = this.buildSyncActions(classified.loopscale);
-        const raw = this.buildRawBundle(tx, instructions, classified.loopscale);
-        return {
-            syncActions,
-            topLevelInstructions: classified.topLevel,
-            setupInstructions: classified.setup,
-            raw,
-        };
-    }
-    async parseStrategyBatches(entries) {
-        return Promise.all(entries.map((entry) => this.parseTransactionEntry(entry)));
-    }
-    async fetchAndClassifyWrappedTx(path, body, headers) {
-        const data = await this.post(path, body, headers);
-        if (!data.transactions?.length) {
-            throw new Error(`Loopscale ${path} returned no transactions`);
-        }
-        if (data.transactions.length > 1) {
-            throw new Error(`Loopscale ${path} returned ${data.transactions.length} transactions — expected 1. ` +
-                `Multi-transaction responses (e.g. from setupIxs) are not supported.`);
-        }
-        const batch = await this.parseTransactionEntry(data.transactions[0]);
-        if (this.debug) {
-            console.log(`[LoopscaleClient] ${path}: syncActions=${batch.syncActions.length}, topLevel=${batch.topLevelInstructions.length}`);
+        const transactionEntry = data.batches?.[0]?.transactions?.[0];
+        if (!transactionEntry) {
+            throw new Error("Loopscale MPC co-signing returned no transaction");
         }
-        return this.toSingleTxResult(batch);
+        const coSignedTransaction = web3_js_1.VersionedTransaction.deserialize(Buffer.from(transactionEntry.transaction, "base64"));
+        return mergeCoSignedTransaction(transaction, coSignedTransaction);
     }
-    async fetchAndClassifySingleTx(path, body, headers) {
-        const entry = await this.post(path, body, headers);
-        const batch = await this.parseTransactionEntry(entry);
-        if (this.debug) {
-            console.log(`[LoopscaleClient] ${path}: syncActions=${batch.syncActions.length}, topLevel=${batch.topLevelInstructions.length}`);
-        }
-        return this.toSingleTxResult(batch);
+    /**
+     * Extract the strategy PDA from a `createStrategy` response using the client's connection.
+     */
+    async extractCreatedStrategyAddress(response) {
+        return extractCreatedStrategyAddress(this.connection, response);
+    }
+    /**
+     * Extract the strategy nonce from a `createStrategy` response using the client's connection.
+     */
+    async extractCreatedStrategyNonce(response) {
+        return extractCreatedStrategyNonce(this.connection, response);
     }
     async post(path, body, extraHeaders) {
         const url = `${this.baseUrl}${path}`;
@@ -695,31 +449,34 @@ class LoopscaleClient {
         };
         if (this.debug) {
             console.log(`\n[LoopscaleClient] POST ${url}`);
-            if (body)
+            if (body !== undefined) {
                 console.log(`  body: ${JSON.stringify(body, null, 2).split("\n").slice(0, 10).join("\n")}...`);
+            }
         }
         let response;
         const maxRetries = 3;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
             response = await fetch(url, {
                 method: "POST",
                 headers,
                 body: body !== undefined ? JSON.stringify(body) : undefined,
             });
             if (response.status === 429 && attempt < maxRetries) {
-                const delay = 2000 * (attempt + 1);
-                if (this.debug)
-                    console.log(`  RATE LIMITED (429), retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})...`);
-                await new Promise((r) => setTimeout(r, delay));
+                const delayMs = 2_000 * (attempt + 1);
+                if (this.debug) {
+                    console.log(`  RATE LIMITED (429), retrying in ${delayMs}ms (attempt ${attempt + 1}/${maxRetries})...`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
                 continue;
             }
             break;
         }
-        if (!response.ok) {
-            const text = await response.text();
-            if (this.debug)
-                console.log(`  ERROR ${response.status}: ${text}`);
-            throw new Error(`Loopscale API ${path} failed (${response.status}): ${text}`);
+        if (!response?.ok) {
+            const text = await response?.text();
+            if (this.debug) {
+                console.log(`  ERROR ${response?.status}: ${text}`);
+            }
+            throw new Error(`Loopscale API ${path} failed (${response?.status}): ${text}`);
         }
         const data = await response.json();
         if (this.debug) {