upshift-config 0.5.14

package/lib/modules/sub-accounts/index.js

@@ -0,0 +1,19 @@
+"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("./fetcher"), exports);
+__exportStar(require("./main"), exports);
+//# sourceMappingURL=index.js.map

package/lib/modules/sub-accounts/main.d.ts

@@ -0,0 +1,243 @@
+import { AugustBase, type IAugustBase } from '../../core';
+import type { IAddress, ILoanBookInfo, ISubaccountDebank, ISubaccountTransaction, IWSSubaccountListItem } from '../../types';
+/**
+ * Subaccount operation class interacting with August Subaccounts
+ * Subaccount is a smart contract wallet that serves as the fundamental infrastructure for August's platform.
+ * It functions as a cross-margin account designed for optimal capital efficiency.
+ * Most of the operations require a August API key to perform
+ */
+export declare class AugustSubAccounts extends AugustBase {
+    private headers;
+    constructor(baseConfig: IAugustBase);
+    /**
+     * Retrieves one page of the directory of all August subaccounts.
+     *
+     * Backed by the admin-only `GET /subaccount` backend endpoint, so the
+     * August API key configured on the SDK must belong to an admin user —
+     * non-admin keys are rejected with an auth error by the backend. Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param options - Pagination window over the subaccount directory
+     * @param options.offset - Number of records to skip. Defaults to 0; must be a non-negative integer.
+     * @param options.limit - Page size. Defaults to 100; must be an integer between 1 and 1000 (backend maximum).
+     * @returns The page of subaccount records (address, internal/friendly names, status, type, linked chains, risk metadata). An empty array means the offset is past the end of the directory.
+     * @throws AugustValidationError when `offset` or `limit` is out of range
+     * @throws AugustAuthError when the API key is missing or not admin-scoped
+     * @example
+     *   const page = await augustSdk.subAccountsModule.getAllSubaccounts({
+     *     offset: 0,
+     *     limit: 200,
+     *   });
+     *   console.log(page.map((s) => `${s.internal_name}: ${s.address}`));
+     */
+    getAllSubaccounts(options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<IWSSubaccountListItem[]>;
+    /**
+     * Retrieves the health factor for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The health factor data including collateral value, loan value, and health factor ratio
+     */
+    getSubaccountHealthFactor(subaccountAddress: IAddress): Promise<{
+        id: `0x${string}`;
+        dateTime: string;
+        healthFactor: number;
+        totalCollateral: number;
+        totalLoan: number;
+    }>;
+    /**
+     * Retrieves loan positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @param side - Filter by loan side: 'BOTH' for all loans, 'LENDER' for lent positions, 'BORROWER' for borrowed positions
+     * @param active - When true, returns only active loans; when false, returns all loans including closed ones
+     * @returns List of loan positions matching the specified filters
+     */
+    getSubaccountLoans(subaccountAddress: IAddress, side: 'BOTH' | 'LENDER' | 'BORROWER', active: boolean): Promise<import("../../types").IWSSubaccountLoan[]>;
+    /**
+     * Retrieves CeFi (Centralized Finance) positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns List of CeFi positions held by the subaccount
+     */
+    getSubaccountCefiPositions(subaccountAddress: IAddress): Promise<import("../../types").IWSSubaccountCefi[]>;
+    /**
+     * Retrieves OTC (Over-The-Counter) positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns List of OTC positions held by the subaccount
+     */
+    getSubaccountOtcPositions(subaccountAddress: IAddress): Promise<import("../../types").IOTCPosition[]>;
+    /**
+     * Retrieves the summary view for a subaccount or EOA operator.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The full summary including portfolio, loanbook, tokens, and account values
+     */
+    getSubaccountSummary(subaccountAddress: IAddress): Promise<{
+        address: `0x${string}`;
+        name: string;
+        type: "eoa" | "subaccount";
+        portfolio: {
+            tokens: {
+                value: number;
+                balance: number;
+                token: {
+                    type: string;
+                    name: string;
+                    address: string;
+                    chain: number;
+                    symbol: string;
+                    decimals: number;
+                    imgUrl: string;
+                };
+            }[];
+            marginBalances: unknown[];
+            collateralBalances: unknown[];
+            cefiPositions: unknown[];
+            defiPositions: unknown[];
+            trsPositions: unknown[];
+            strategyContractPositions: unknown[];
+            legacyHedgerPositions: unknown[];
+            otcPositions: unknown[];
+            totalValue: number;
+            discountedValue: number;
+        };
+        loanbook: {
+            loans: {
+                subaccountAddress: `0x${string}`;
+                book: {
+                    address: `0x${string}`;
+                    lender: `0x${string}`;
+                    borrower: `0x${string}`;
+                    state: string;
+                    totalRepaid: number;
+                    principalToken: {
+                        type: string;
+                        name: string;
+                        address: string;
+                        chain: number;
+                        symbol: string;
+                        decimals: number;
+                        imgUrl: string;
+                        tokenType: number;
+                        discountFactor: number;
+                        price: number;
+                    };
+                    principalAmount: number;
+                    interestAmount: number;
+                    upcomingPayment: {
+                        amount: number;
+                        dueDate: string;
+                    };
+                    apr: number;
+                    initialPrincipalAmount: number;
+                    deployedDate: string;
+                    paymentInterval: number;
+                    totalInterestPaymentFees: number;
+                };
+                isBorrow: boolean;
+                debtInfo: {
+                    interestOwed: number;
+                    principalDebtOwed: number;
+                    interestRepaid: number;
+                };
+                creditInfo: {
+                    netInterestOwed: number;
+                    principalDebtOwed: number;
+                    netInterestRepaid: number;
+                };
+            }[];
+            totalDebt: number;
+            totalCredit: number;
+            aggregatesByToken: unknown[];
+        };
+        chains: {
+            name: string;
+            chainId: number;
+        }[];
+        tokens: {
+            type: string;
+            name: string;
+            address: string;
+            chain: number;
+            symbol: string;
+            decimals: number;
+            imgUrl: string;
+            price: number;
+            rawBalance: number;
+            balance: number;
+            value: number;
+        }[];
+        totalAccountValue: number;
+        totalCollateralValue: number;
+        totalLoanValue: number;
+        healthFactor: number;
+        netAccountValue: number;
+        totalEquityValue: number;
+    }>;
+    /**
+     * Retrieves a subaccount's on-chain transaction history, newest first,
+     * optionally windowed by a time range.
+     *
+     * Backed by the authenticated `GET /transactions/v2` backend endpoint,
+     * which resolves and authorizes the subaccount, so the configured August
+     * API key must be authorized for it (an admin-scoped key always is). Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @param options - Optional time window
+     * @param options.startTime - ISO-8601 datetime lower bound (inclusive); omit for no lower bound
+     * @param options.endTime - ISO-8601 datetime upper bound (inclusive); omit for no upper bound
+     * @returns The subaccount's transactions with decoded logs, transfers, and function names
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustAuthError When the API key is missing or not authorized for the subaccount
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const txs = await augustSdk.subAccountsModule.getSubaccountTransactions(
+     *     '0xabc…',
+     *     { startTime: '2026-01-01T00:00:00Z' },
+     *   );
+     */
+    getSubaccountTransactions(subaccountAddress: IAddress, options?: {
+        startTime?: string;
+        endTime?: string;
+    }): Promise<ISubaccountTransaction[]>;
+    /**
+     * Retrieves the full loan-book detail for a single loan by its address and
+     * chain.
+     *
+     * Backed by the admin-only `GET /subaccount/loans/{loan_address}` backend
+     * endpoint (60-second server-side cache), so the configured August API key
+     * must belong to an admin user. Makes exactly one HTTP request and no RPC
+     * calls.
+     *
+     * @param loanAddress - The loan contract address
+     * @param chainId - Numeric August chain id the loan lives on (e.g. `1` for Ethereum mainnet)
+     * @returns The loan's {@link ILoanBookInfo} detail
+     * @throws AugustValidationError When `chainId` is not an integer
+     * @throws AugustAuthError When the API key is missing or not admin-scoped
+     * @throws AugustServerError When the loan or chain is not found, or the API otherwise responds non-2xx
+     * @example
+     *   const loan = await augustSdk.subAccountsModule.getSubaccountLoanByAddress(
+     *     '0xloan…',
+     *     1,
+     *   );
+     */
+    getSubaccountLoanByAddress(loanAddress: string, chainId: number): Promise<ILoanBookInfo>;
+    /**
+     * Retrieves cross-chain DeBank protocol positions and token balances for a
+     * subaccount and its associated strategies.
+     *
+     * Backed by `GET /subaccount/{subaccount_address}/debank` (300-second
+     * server-side cache). This is a slow endpoint — it fans out to DeBank
+     * across every supported chain — so expect higher latency than other
+     * subaccount reads. Makes exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The subaccount's DeBank positions/tokens plus per-strategy breakdowns
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const debank = await augustSdk.subAccountsModule.getSubaccountDebank('0xabc…');
+     *   console.log(debank.subaccount.positions.length);
+     */
+    getSubaccountDebank(subaccountAddress: IAddress): Promise<ISubaccountDebank>;
+}

package/lib/modules/sub-accounts/main.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AugustSubAccounts = void 0;
+/**
+ * The August Sub Accounts Module.
+ *
+ * @module AugustSubAccounts
+ */
+const fetcher_1 = require("./fetcher");
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+const core_1 = require("../../core");
+/**
+ * Validates that a subaccount address is a well-formed EVM address, throwing a
+ * typed {@link AugustValidationError} if not. August subaccounts are EVM
+ * smart-contract wallets, so an invalid value should fail fast in the SDK
+ * rather than reaching the backend.
+ */
+function assertSubaccountAddress(address, method) {
+    if (typeof address !== 'string' || !(0, ethers_1.isAddress)(address)) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `${method}: "${address}" is not a valid subaccount address — pass the subaccount's EVM (0x…) address.`);
+    }
+}
+/**
+ * Subaccount operation class interacting with August Subaccounts
+ * Subaccount is a smart contract wallet that serves as the fundamental infrastructure for August's platform.
+ * It functions as a cross-margin account designed for optimal capital efficiency.
+ * Most of the operations require a August API key to perform
+ */
+class AugustSubAccounts extends core_1.AugustBase {
+    headers = null;
+    constructor(baseConfig) {
+        super(baseConfig);
+        this.headers = {
+            'x-environment': this.monitoring?.['x-environment'],
+            'x-user-id': this.monitoring?.['x-user-id'],
+        };
+    }
+    /**
+     * Retrieves one page of the directory of all August subaccounts.
+     *
+     * Backed by the admin-only `GET /subaccount` backend endpoint, so the
+     * August API key configured on the SDK must belong to an admin user —
+     * non-admin keys are rejected with an auth error by the backend. Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param options - Pagination window over the subaccount directory
+     * @param options.offset - Number of records to skip. Defaults to 0; must be a non-negative integer.
+     * @param options.limit - Page size. Defaults to 100; must be an integer between 1 and 1000 (backend maximum).
+     * @returns The page of subaccount records (address, internal/friendly names, status, type, linked chains, risk metadata). An empty array means the offset is past the end of the directory.
+     * @throws AugustValidationError when `offset` or `limit` is out of range
+     * @throws AugustAuthError when the API key is missing or not admin-scoped
+     * @example
+     *   const page = await augustSdk.subAccountsModule.getAllSubaccounts({
+     *     offset: 0,
+     *     limit: 200,
+     *   });
+     *   console.log(page.map((s) => `${s.internal_name}: ${s.address}`));
+     */
+    async getAllSubaccounts(options = {}) {
+        const offset = options.offset ?? 0;
+        const limit = options.limit ?? 100;
+        if (!Number.isInteger(offset) || offset < 0) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getAllSubaccounts: offset must be a non-negative integer, got ${offset}`);
+        }
+        if (!Number.isInteger(limit) || limit < 1 || limit > 1000) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `getAllSubaccounts: limit must be an integer between 1 and 1000, got ${limit}`);
+        }
+        return (0, fetcher_1.fetchAllSubaccounts)({ offset, limit }, this.keys.august, this.headers);
+    }
+    /**
+     * Retrieves the health factor for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The health factor data including collateral value, loan value, and health factor ratio
+     */
+    async getSubaccountHealthFactor(subaccountAddress) {
+        const response = await (0, fetcher_1.fetchSubaccountHeathFactor)(subaccountAddress, this.keys.august, this.headers);
+        return {
+            id: response.id,
+            dateTime: response.datetime,
+            healthFactor: response.health_factor,
+            totalCollateral: response.total_collateral_value,
+            totalLoan: response.total_loan_value,
+        };
+    }
+    /**
+     * Retrieves loan positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @param side - Filter by loan side: 'BOTH' for all loans, 'LENDER' for lent positions, 'BORROWER' for borrowed positions
+     * @param active - When true, returns only active loans; when false, returns all loans including closed ones
+     * @returns List of loan positions matching the specified filters
+     */
+    async getSubaccountLoans(subaccountAddress, side, active) {
+        const response = await (0, fetcher_1.fetchSubaccountLoans)({ address: subaccountAddress, active, side }, this.keys.august, this.headers);
+        return response;
+    }
+    /**
+     * Retrieves CeFi (Centralized Finance) positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns List of CeFi positions held by the subaccount
+     */
+    async getSubaccountCefiPositions(subaccountAddress) {
+        const response = await (0, fetcher_1.fetchSubaccountCefiPositions)(subaccountAddress, this.keys.august, this.headers);
+        return response;
+    }
+    /**
+     * Retrieves OTC (Over-The-Counter) positions for a subaccount.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns List of OTC positions held by the subaccount
+     */
+    async getSubaccountOtcPositions(subaccountAddress) {
+        const response = await (0, fetcher_1.fetchSubaccountOtcPositions)(subaccountAddress, this.keys.august, this.headers);
+        return response;
+    }
+    /**
+     * Retrieves the summary view for a subaccount or EOA operator.
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The full summary including portfolio, loanbook, tokens, and account values
+     */
+    async getSubaccountSummary(subaccountAddress) {
+        const response = await (0, fetcher_1.fetchSubaccountSummary)(subaccountAddress, this.keys.august, this.headers);
+        return (0, utils_1.transformSubaccountSummary)(response);
+    }
+    /**
+     * Retrieves a subaccount's on-chain transaction history, newest first,
+     * optionally windowed by a time range.
+     *
+     * Backed by the authenticated `GET /transactions/v2` backend endpoint,
+     * which resolves and authorizes the subaccount, so the configured August
+     * API key must be authorized for it (an admin-scoped key always is). Makes
+     * exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @param options - Optional time window
+     * @param options.startTime - ISO-8601 datetime lower bound (inclusive); omit for no lower bound
+     * @param options.endTime - ISO-8601 datetime upper bound (inclusive); omit for no upper bound
+     * @returns The subaccount's transactions with decoded logs, transfers, and function names
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustAuthError When the API key is missing or not authorized for the subaccount
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const txs = await augustSdk.subAccountsModule.getSubaccountTransactions(
+     *     '0xabc…',
+     *     { startTime: '2026-01-01T00:00:00Z' },
+     *   );
+     */
+    async getSubaccountTransactions(subaccountAddress, options = {}) {
+        assertSubaccountAddress(subaccountAddress, 'getSubaccountTransactions');
+        return (0, fetcher_1.fetchSubaccountTransactions)({
+            address: subaccountAddress,
+            startTime: options.startTime,
+            endTime: options.endTime,
+        }, this.keys.august, this.headers);
+    }
+    /**
+     * Retrieves the full loan-book detail for a single loan by its address and
+     * chain.
+     *
+     * Backed by the admin-only `GET /subaccount/loans/{loan_address}` backend
+     * endpoint (60-second server-side cache), so the configured August API key
+     * must belong to an admin user. Makes exactly one HTTP request and no RPC
+     * calls.
+     *
+     * @param loanAddress - The loan contract address
+     * @param chainId - Numeric August chain id the loan lives on (e.g. `1` for Ethereum mainnet)
+     * @returns The loan's {@link ILoanBookInfo} detail
+     * @throws AugustValidationError When `chainId` is not an integer
+     * @throws AugustAuthError When the API key is missing or not admin-scoped
+     * @throws AugustServerError When the loan or chain is not found, or the API otherwise responds non-2xx
+     * @example
+     *   const loan = await augustSdk.subAccountsModule.getSubaccountLoanByAddress(
+     *     '0xloan…',
+     *     1,
+     *   );
+     */
+    async getSubaccountLoanByAddress(loanAddress, chainId) {
+        if (!Number.isInteger(chainId)) {
+            throw new core_1.AugustValidationError('INVALID_CHAIN', `getSubaccountLoanByAddress: chainId must be an integer August chain id, got ${chainId}.`);
+        }
+        return (0, fetcher_1.fetchSubaccountLoanByAddress)(loanAddress, chainId, this.keys.august, this.headers);
+    }
+    /**
+     * Retrieves cross-chain DeBank protocol positions and token balances for a
+     * subaccount and its associated strategies.
+     *
+     * Backed by `GET /subaccount/{subaccount_address}/debank` (300-second
+     * server-side cache). This is a slow endpoint — it fans out to DeBank
+     * across every supported chain — so expect higher latency than other
+     * subaccount reads. Makes exactly one HTTP request and no RPC calls.
+     *
+     * @param subaccountAddress - The address of the subaccount to query
+     * @returns The subaccount's DeBank positions/tokens plus per-strategy breakdowns
+     * @throws AugustValidationError When `subaccountAddress` is not a valid EVM address
+     * @throws AugustServerError When the API responds with a non-2xx status
+     * @example
+     *   const debank = await augustSdk.subAccountsModule.getSubaccountDebank('0xabc…');
+     *   console.log(debank.subaccount.positions.length);
+     */
+    async getSubaccountDebank(subaccountAddress) {
+        assertSubaccountAddress(subaccountAddress, 'getSubaccountDebank');
+        return (0, fetcher_1.fetchSubaccountDebank)(subaccountAddress, this.keys.august, this.headers);
+    }
+}
+exports.AugustSubAccounts = AugustSubAccounts;
+//# sourceMappingURL=main.js.map

package/lib/modules/sub-accounts/utils.d.ts

@@ -0,0 +1,106 @@
+import type { IWSSubaccountSummary } from '../../types';
+/**
+ * Transform the raw API response to camelCase
+ */
+export declare const transformSubaccountSummary: (response: IWSSubaccountSummary) => {
+    address: `0x${string}`;
+    name: string;
+    type: "eoa" | "subaccount";
+    portfolio: {
+        tokens: {
+            value: number;
+            balance: number;
+            token: {
+                type: string;
+                name: string;
+                address: string;
+                chain: number;
+                symbol: string;
+                decimals: number;
+                imgUrl: string;
+            };
+        }[];
+        marginBalances: unknown[];
+        collateralBalances: unknown[];
+        cefiPositions: unknown[];
+        defiPositions: unknown[];
+        trsPositions: unknown[];
+        strategyContractPositions: unknown[];
+        legacyHedgerPositions: unknown[];
+        otcPositions: unknown[];
+        totalValue: number;
+        discountedValue: number;
+    };
+    loanbook: {
+        loans: {
+            subaccountAddress: `0x${string}`;
+            book: {
+                address: `0x${string}`;
+                lender: `0x${string}`;
+                borrower: `0x${string}`;
+                state: string;
+                totalRepaid: number;
+                principalToken: {
+                    type: string;
+                    name: string;
+                    address: string;
+                    chain: number;
+                    symbol: string;
+                    decimals: number;
+                    imgUrl: string;
+                    tokenType: number;
+                    discountFactor: number;
+                    price: number;
+                };
+                principalAmount: number;
+                interestAmount: number;
+                upcomingPayment: {
+                    amount: number;
+                    dueDate: string;
+                };
+                apr: number;
+                initialPrincipalAmount: number;
+                deployedDate: string;
+                paymentInterval: number;
+                totalInterestPaymentFees: number;
+            };
+            isBorrow: boolean;
+            debtInfo: {
+                interestOwed: number;
+                principalDebtOwed: number;
+                interestRepaid: number;
+            };
+            creditInfo: {
+                netInterestOwed: number;
+                principalDebtOwed: number;
+                netInterestRepaid: number;
+            };
+        }[];
+        totalDebt: number;
+        totalCredit: number;
+        aggregatesByToken: unknown[];
+    };
+    chains: {
+        name: string;
+        chainId: number;
+    }[];
+    tokens: {
+        type: string;
+        name: string;
+        address: string;
+        chain: number;
+        symbol: string;
+        decimals: number;
+        imgUrl: string;
+        price: number;
+        rawBalance: number;
+        balance: number;
+        value: number;
+    }[];
+    totalAccountValue: number;
+    totalCollateralValue: number;
+    totalLoanValue: number;
+    healthFactor: number;
+    netAccountValue: number;
+    totalEquityValue: number;
+};

package/lib/modules/sub-accounts/utils.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSubaccountSummary = void 0;
+/**
+ * Transform the raw API response to camelCase
+ */
+const transformSubaccountSummary = (response) => {
+    return {
+        address: response.address,
+        name: response.name,
+        type: response.type,
+        portfolio: {
+            tokens: response.portfolio.tokens.map((t) => ({
+                value: t.value,
+                balance: t.balance,
+                token: {
+                    type: t.token.type,
+                    name: t.token.name,
+                    address: t.token.address,
+                    chain: t.token.chain,
+                    symbol: t.token.symbol,
+                    decimals: t.token.decimals,
+                    imgUrl: t.token.img_url,
+                },
+            })),
+            marginBalances: response.portfolio.margin_balances,
+            collateralBalances: response.portfolio.collateral_balances,
+            cefiPositions: response.portfolio.cefi_positions,
+            defiPositions: response.portfolio.defi_positions,
+            trsPositions: response.portfolio.trs_positions,
+            strategyContractPositions: response.portfolio.strategy_contract_positions,
+            legacyHedgerPositions: response.portfolio.legacy_hedger_positions,
+            otcPositions: response.portfolio.otc_positions,
+            totalValue: response.portfolio.total_value,
+            discountedValue: response.portfolio.discounted_value,
+        },
+        loanbook: {
+            loans: response.loanbook.loans.map((loan) => ({
+                subaccountAddress: loan.subaccount_address,
+                book: {
+                    address: loan.book.address,
+                    lender: loan.book.lender,
+                    borrower: loan.book.borrower,
+                    state: loan.book.state,
+                    totalRepaid: loan.book.total_repaid,
+                    principalToken: {
+                        type: loan.book.principal_token.type,
+                        name: loan.book.principal_token.name,
+                        address: loan.book.principal_token.address,
+                        chain: loan.book.principal_token.chain,
+                        symbol: loan.book.principal_token.symbol,
+                        decimals: loan.book.principal_token.decimals,
+                        imgUrl: loan.book.principal_token.img_url,
+                        tokenType: loan.book.principal_token.token_type,
+                        discountFactor: loan.book.principal_token.discount_factor,
+                        price: loan.book.principal_token.price,
+                    },
+                    principalAmount: loan.book.principal_amount,
+                    interestAmount: loan.book.interest_amount,
+                    upcomingPayment: {
+                        amount: loan.book.upcoming_payment.amount,
+                        dueDate: loan.book.upcoming_payment.due_date,
+                    },
+                    apr: loan.book.apr,
+                    initialPrincipalAmount: loan.book.initial_principal_amount,
+                    deployedDate: loan.book.deployed_date,
+                    paymentInterval: loan.book.payment_interval,
+                    totalInterestPaymentFees: loan.book.total_interest_payment_fees,
+                },
+                isBorrow: loan.is_borrow,
+                debtInfo: {
+                    interestOwed: loan.debt_info.interest_owed,
+                    principalDebtOwed: loan.debt_info.principal_debt_owed,
+                    interestRepaid: loan.debt_info.interest_repaid,
+                },
+                creditInfo: {
+                    netInterestOwed: loan.credit_info.net_interest_owed,
+                    principalDebtOwed: loan.credit_info.principal_debt_owed,
+                    netInterestRepaid: loan.credit_info.net_interest_repaid,
+                },
+            })),
+            totalDebt: response.loanbook.total_debt,
+            totalCredit: response.loanbook.total_credit,
+            aggregatesByToken: response.loanbook.aggregates_by_token,
+        },
+        chains: response.chains.map((c) => ({
+            name: c.name,
+            chainId: c.chain_id,
+        })),
+        tokens: response.tokens.map((t) => ({
+            type: t.type,
+            name: t.name,
+            address: t.address,
+            chain: t.chain,
+            symbol: t.symbol,
+            decimals: t.decimals,
+            imgUrl: t.img_url,
+            price: t.price,
+            rawBalance: t.raw_balance,
+            balance: t.balance,
+            value: t.value,
+        })),
+        totalAccountValue: response.total_account_value,
+        totalCollateralValue: response.total_collateral_value,
+        totalLoanValue: response.total_loan_value,
+        healthFactor: response.health_factor,
+        netAccountValue: response.net_account_value,
+        totalEquityValue: response.total_equity_value,
+    };
+};
+exports.transformSubaccountSummary = transformSubaccountSummary;
+//# sourceMappingURL=utils.js.map