@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/exponentVaults/loopscale-client.js

@@ -0,0 +1,732 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopscaleClient = 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"),
+    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();
+}
+function toSafeNumber(value, field) {
+    if (typeof value === "bigint") {
+        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`);
+        return Number(value);
+    }
+    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 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;
+}
+async function decompileInstructions(connection, transaction) {
+    const lookupTableAccounts = await 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);
+    }
+    return tx;
+}
+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;
+        }
+    }
+    return resultTx;
+}
+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");
+    }
+}
+// ============================================================================
+// LoopscaleClient
+// ============================================================================
+class LoopscaleClient {
+    connection;
+    baseUrl;
+    userWallet;
+    bsAuth;
+    useMpcCoSign;
+    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.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 ──
+    async getQuotes(params) {
+        const body = {
+            durationType: params.durationType,
+            duration: params.duration,
+            principal: toBase58(params.principal),
+            collateral: params.collateral.map(toBase58),
+            limit: params.limit ?? 10,
+            offset: params.offset ?? 0,
+        };
+        return this.post("/markets/quote", body, { "user-wallet": this.userWallet });
+    }
+    async getMaxQuote(params) {
+        const body = {
+            durationType: params.durationType,
+            duration: params.duration,
+            principalMint: toBase58(params.principalMint),
+            collateralFilter: params.collateralFilter.map((f) => ({
+                amount: toSafeNumber(f.amount, "amount"),
+                assetData: f.assetData,
+            })),
+        };
+        return this.post("/markets/quote/max", body, { "user-wallet": this.userWallet });
+    }
+    async getLoanInfo(params) {
+        return this.post("/markets/loans/info", params, { "user-wallet": this.userWallet });
+    }
+    async getStrategies(params) {
+        return this.post("/markets/strategy/infos", params, { "user-wallet": this.userWallet });
+    }
+    async getCollateralHolders(params) {
+        return this.post("/markets/collateral/holders", 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) ──
+    async createStrategy(params) {
+        const lender = toBase58(params.lender);
+        const body = {
+            principalMint: toBase58(params.principalMint),
+            lender,
+            amount: toSafeNumber(params.amount, "amount"),
+        };
+        if (params.originationsEnabled !== undefined)
+            body.originationsEnabled = params.originationsEnabled;
+        if (params.liquidityBuffer !== undefined)
+            body.liquidityBuffer = params.liquidityBuffer;
+        if (params.interestFee !== undefined)
+            body.interestFee = params.interestFee;
+        if (params.originationFee !== undefined)
+            body.originationFee = params.originationFee;
+        if (params.originationCap !== undefined)
+            body.originationCap = params.originationCap;
+        if (params.collateralTerms)
+            body.collateralTerms = params.collateralTerms;
+        if (params.marketInformation)
+            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 };
+    }
+    async depositStrategy(params) {
+        const body = {
+            strategy: toBase58(params.strategy),
+            amount: toSafeNumber(params.amount, "amount"),
+        };
+        return this.fetchAndClassifySingleTx("/markets/strategy/deposit", body, {
+            "User-Wallet": this.userWallet,
+            payer: this.userWallet,
+        });
+    }
+    async withdrawStrategy(params) {
+        const body = {
+            strategy: toBase58(params.strategy),
+            amount: toSafeNumber(params.amount, "amount"),
+            withdrawAll: params.withdrawAll,
+        };
+        return this.fetchAndClassifySingleTx("/markets/strategy/withdraw", body, {
+            "User-Wallet": this.userWallet,
+            payer: this.userWallet,
+        });
+    }
+    async closeStrategy(params) {
+        const strategy = toBase58(params.strategy);
+        return this.fetchAndClassifySingleTx(`/markets/strategy/close/${strategy}`, undefined, {
+            payer: this.userWallet,
+        });
+    }
+    async updateStrategy(params) {
+        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;
+    }
+    /**
+     * Build a standalone borrow_principal wrapped as a LoopscaleInstruction for sync tx.
+     * Requires collateral to already be deposited in the loan.
+     */
+    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,
+            })),
+            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] },
+            })),
+        };
+        if (params.assetIndexGuidance)
+            body.assetIndexGuidance = params.assetIndexGuidance;
+        if (params.loanNonce)
+            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 };
+    }
+    async apiBorrowPrincipal(params) {
+        const borrowParams = {
+            amount: toSafeNumber(params.borrowParams.amount, "amount"),
+            duration: params.borrowParams.durationIndex,
+        };
+        if (params.borrowParams.expectedLoanValues) {
+            borrowParams.expectedLoanValues = params.borrowParams.expectedLoanValues;
+        }
+        const body = {
+            loan: toBase58(params.loan),
+            borrowParams,
+            strategy: toBase58(params.strategy),
+        };
+        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 });
+    }
+    async depositCollateral(params) {
+        const body = {
+            loan: toBase58(params.loan),
+            depositMint: toBase58(params.depositMint),
+            amount: toSafeNumber(params.amount, "amount"),
+            assetType: params.assetType,
+            assetIdentifier: toBase58(params.assetIdentifier),
+        };
+        if (params.assetIndexGuidance)
+            body.assetIndexGuidance = params.assetIndexGuidance;
+        if (params.expectedLoanValues)
+            body.expectedLoanValues = params.expectedLoanValues;
+        return this.fetchAndClassifySingleTx("/markets/creditbook/collateral/deposit", body, {
+            "user-wallet": this.userWallet,
+            payer: this.userWallet,
+        });
+    }
+    async withdrawCollateral(params) {
+        const body = {
+            loan: toBase58(params.loan),
+            collateralMint: toBase58(params.collateralMint),
+            amount: toSafeNumber(params.amount, "amount"),
+            collateralIndex: params.collateralIndex,
+        };
+        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, {
+            "user-wallet": this.userWallet,
+        });
+    }
+    // ── Co-signing ──
+    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);
+        });
+    }
+    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}`);
+        }
+        return this.toSingleTxResult(batch);
+    }
+    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);
+    }
+    async post(path, body, extraHeaders) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+            ...extraHeaders,
+        };
+        if (this.debug) {
+            console.log(`\n[LoopscaleClient] POST ${url}`);
+            if (body)
+                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++) {
+            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));
+                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}`);
+        }
+        const data = await response.json();
+        if (this.debug) {
+            console.log(`  OK ${response.status}`);
+        }
+        return data;
+    }
+}
+exports.LoopscaleClient = LoopscaleClient;
+//# sourceMappingURL=loopscale-client.js.map