@augustdigital/sdk 7.0.1 → 8.2.0

package/lib/abis/index.d.ts

@@ -26,3 +26,4 @@ export * from './MultiAssetNativeDepositWrapper';
 export * from './TokenizedVaultV2SenderAllocationWhitelist';
 export * from './RwaRedeemSubaccount';
 export * from './OFT';
+export * from './SwapRouter';

package/lib/abis/index.js

@@ -42,4 +42,5 @@ __exportStar(require("./MultiAssetNativeDepositWrapper"), exports);
 __exportStar(require("./TokenizedVaultV2SenderAllocationWhitelist"), exports);
 __exportStar(require("./RwaRedeemSubaccount"), exports);
 __exportStar(require("./OFT"), exports);
+__exportStar(require("./SwapRouter"), exports);
 //# sourceMappingURL=index.js.map

package/lib/adapters/evm/index.d.ts

@@ -1,4 +1,5 @@
 import { IContractWriteOptions, INativeDepositOptions, ApproveResult } from '../../modules/vaults/write.actions';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
 import { IPreviewDepositOptions, IPreviewRedeemOptions, IAllowanceOptions, IBalanceOfOptions, IMaxDepositOptions } from '../../modules/vaults/read.actions';
 import { CompatibleSigner } from '../../core/helpers/signer';
 import { IAddress } from '../../types';
@@ -15,6 +16,9 @@ declare class EVMAdapter {
     vaultDeposit(options: IContractWriteOptions): Promise<string>;
     vaultRequestRedeem(options: IContractWriteOptions): Promise<string>;
     depositNative(options: INativeDepositOptions): Promise<string>;
+    swapAndDeposit(options: ISwapAndDepositOptions): Promise<string>;
+    depositViaSwapRouter(options: ISwapRouterDirectDepositOptions): Promise<string>;
+    depositNativeViaSwapRouter(options: ISwapRouterNativeDepositOptions): Promise<string>;
     vaultRedeem(options: IContractWriteOptions & {
         year: string;
         month: string;

package/lib/adapters/evm/index.js

@@ -60,6 +60,18 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, write_actions_1.depositNative)(signer, options);
     }
+    async swapAndDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.swapAndDeposit)(signer, options);
+    }
+    async depositViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositViaSwapRouter)(signer, options);
+    }
+    async depositNativeViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositNativeViaSwapRouter)(signer, options);
+    }
     async vaultRedeem(options) {
         const signer = await this.getSigner();
         return (0, write_actions_1.vaultRedeem)(signer, options);

package/lib/adapters/stellar/types.d.ts

@@ -1,6 +1,5 @@
 import type { IStellarNetwork } from '../../types/web3';
 export type { IStellarNetwork };
-export type { IStellarNetwork as StellarNetwork };
 export interface IStellarDepositParams {
     contractId: string;
     amount: string;

package/lib/core/analytics/method-taxonomy.js

@@ -65,6 +65,9 @@ exports.METHOD_CATEGORIES = {
     maxDeposit: 'read.vault',
     vaultDeposit: 'write.deposit',
     depositNative: 'write.deposit',
+    swapAndDeposit: 'write.deposit',
+    depositViaSwapRouter: 'write.deposit',
+    depositNativeViaSwapRouter: 'write.deposit',
     vaultRedeem: 'write.redeem',
     vaultRequestRedeem: 'write.redeem',
     rwaRedeemAsset: 'write.redeem',

package/lib/core/analytics/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "7.0.1";
+export declare const SDK_VERSION = "8.2.0";

package/lib/core/analytics/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '7.0.1';
+exports.SDK_VERSION = '8.2.0';
 //# sourceMappingURL=version.js.map

package/lib/core/base.class.d.ts

@@ -5,7 +5,6 @@ interface IKeys {
     august?: string;
     graph?: string;
     coingecko?: string;
-    octavfi?: string;
 }
 interface IMonitoring extends IWSMonitorHeaders {
     slackWebhookUrl?: string;

package/lib/core/constants/swap-router.d.ts

@@ -0,0 +1,8 @@
+import { IAddress } from '../../types';
+export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
+export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
+export declare const ORIGIN_CODES: {
+    readonly default: `0x${string}`;
+};
+export declare const SWAP_ROUTER_MAX_SWAPS = 9;
+export declare const SWAP_ROUTER_WRAPPED_NATIVE: Readonly<Record<number, IAddress>>;

package/lib/core/constants/swap-router.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWAP_ROUTER_WRAPPED_NATIVE = exports.SWAP_ROUTER_MAX_SWAPS = exports.ORIGIN_CODES = exports.VAULTS_USING_SWAP_ROUTER = exports.SWAP_ROUTER_ADDRESSES = void 0;
+exports.SWAP_ROUTER_ADDRESSES = {
+    1: '0xAC771209FF2b71EECfF6E85a9AD01db8Ff2618B0',
+};
+exports.VAULTS_USING_SWAP_ROUTER = new Set([
+    '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+    '0x74ad2f789ed583dbd141bbdafc673fe1f033718b',
+]);
+exports.ORIGIN_CODES = {
+    default: '0x0000000000000000000000000000000000000000000000000000000000000000',
+};
+exports.SWAP_ROUTER_MAX_SWAPS = 9;
+exports.SWAP_ROUTER_WRAPPED_NATIVE = {
+    1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+};
+//# sourceMappingURL=swap-router.js.map

package/lib/core/helpers/swap-router.d.ts

@@ -0,0 +1,4 @@
+import { IAddress } from '../../types';
+export declare function getSwapRouterAddress(chainId: number): IAddress | undefined;
+export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
+export declare function resolveOriginCode(provided?: `0x${string}`): `0x${string}`;

package/lib/core/helpers/swap-router.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwapRouterAddress = getSwapRouterAddress;
+exports.vaultUsesSwapRouter = vaultUsesSwapRouter;
+exports.resolveOriginCode = resolveOriginCode;
+const swap_router_1 = require("../constants/swap-router");
+const errors_1 = require("../errors");
+function getSwapRouterAddress(chainId) {
+    return swap_router_1.SWAP_ROUTER_ADDRESSES[chainId];
+}
+function vaultUsesSwapRouter(vaultAddress) {
+    return swap_router_1.VAULTS_USING_SWAP_ROUTER.has(vaultAddress.toLowerCase());
+}
+function resolveOriginCode(provided) {
+    if (provided === undefined)
+        return swap_router_1.ORIGIN_CODES.default;
+    if (!/^0x[0-9a-fA-F]{64}$/.test(provided)) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', `resolveOriginCode: originCode must be a 32-byte hex string (66 chars incl. 0x), got "${provided}" (${provided.length} chars)`, { context: { provided, expectedLength: 66 } });
+    }
+    return provided;
+}
+//# sourceMappingURL=swap-router.js.map

package/lib/core/index.d.ts

@@ -9,8 +9,10 @@ export * from './constants/adapters';
 export * from './constants/core';
 export * from './constants/web3';
 export * from './constants/vaults';
+export * from './constants/swap-router';
 export * from './helpers/web3';
 export * from './helpers/vaults';
 export * from './helpers/core';
 export * from './helpers/adapters';
 export * from './helpers/signer';
+export * from './helpers/swap-router';

package/lib/core/index.js

@@ -25,9 +25,11 @@ __exportStar(require("./constants/adapters"), exports);
 __exportStar(require("./constants/core"), exports);
 __exportStar(require("./constants/web3"), exports);
 __exportStar(require("./constants/vaults"), exports);
+__exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
 __exportStar(require("./helpers/vaults"), exports);
 __exportStar(require("./helpers/core"), exports);
 __exportStar(require("./helpers/adapters"), exports);
 __exportStar(require("./helpers/signer"), exports);
+__exportStar(require("./helpers/swap-router"), exports);
 //# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * from './types';
 export * from './core';
 export * from './abis';
 export * from './services/debank';
+export * from './services/swap-quotes';
 export * from './modules/vaults';
 export * from './modules/sub-accounts';
 export * from './evm';

package/lib/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
 __exportStar(require("./abis"), exports);
 __exportStar(require("./services/debank"), exports);
+__exportStar(require("./services/swap-quotes"), exports);
 __exportStar(require("./modules/vaults"), exports);
 __exportStar(require("./modules/sub-accounts"), exports);
 __exportStar(require("./evm"), exports);

package/lib/main.d.ts

@@ -138,7 +138,8 @@ export declare class AugustSDK extends AugustBase {
     }): Promise<import("./types").IActiveStakingPosition[]>;
     getVaultBorrowerHealthFactor(props?: {
         chainId?: IChainId;
-    }): Promise<{}>;
+        vault?: IAddress;
+    }): Promise<Record<string, import("./types").IVaultBorrowerHealthFactor[]> | Record<string, import("./types").IVaultBorrowerHealthFactor[]>[]>;
     getUserPoints(userAddress: IAddress): Promise<any>;
     registerUserForPoints(userAddress: IAddress, referrerAddress: IAddress | undefined, chainId: number, signature: string, nonce: string, expiry: number): Promise<Response>;
     fetchPointsLeaderboard(params?: {

package/lib/main.js

@@ -170,7 +170,7 @@ class AugustSDK extends core_1.AugustBase {
         return await this.vaults.getStakingPositions(props.wallet, props.chainId);
     }
     async getVaultBorrowerHealthFactor(props) {
-        return await this.vaults.getVaultBorrowerHealthFactor(props?.chainId);
+        return await this.vaults.getVaultBorrowerHealthFactor(props?.chainId, props?.vault);
     }
     async getUserPoints(userAddress) {
         return await this.vaults.getUserPoints(userAddress);

package/lib/modules/vaults/fetcher.js

@@ -54,7 +54,7 @@ async function fetchVaultsBatch(vaults, options = {}) {
                     maxRetries,
                     baseDelay,
                 });
-                if (result.success && result.data) {
+                if (result.success) {
                     successful.push({
                         index: globalIndex,
                         data: result.data,
@@ -64,7 +64,7 @@ async function fetchVaultsBatch(vaults, options = {}) {
                 else {
                     failed.push({
                         index: globalIndex,
-                        error: result.error || new Error('Unknown failure'),
+                        error: result.error ?? new Error('Unknown failure'),
                         address: vault.address,
                     });
                 }

package/lib/modules/vaults/getters.d.ts

@@ -1,4 +1,4 @@
-import { IAddress, IHistoricalTimeseriesResponse, INormalizedNumber, ISubgraphWithdrawProccessed, IVault, IVaultAllocations, IVaultAnnualizedApy, IVaultAvailableRedemption, IVaultLoan, IVaultPosition, IVaultRedemptionHistoryItem, IVaultSummary, IVaultWithdrawals, IVaultPendingRedemptions, IActiveStakingPosition, IVaultHistoricalParams, IVaultUserLifetimePnl, IVaultPnl, VaultAddress } from '../../types';
+import { IAddress, IHistoricalTimeseriesResponse, INormalizedNumber, ISubgraphWithdrawProccessed, IVault, IVaultAllocations, IVaultAnnualizedApy, IVaultAvailableRedemption, IVaultLoan, IVaultPosition, IVaultRedemptionHistoryItem, IVaultSummary, IVaultWithdrawals, IVaultPendingRedemptions, IActiveStakingPosition, IVaultHistoricalParams, IVaultUserLifetimePnl, IVaultBorrowerHealthFactor, IVaultPnl, VaultAddress } from '../../types';
 import { IVaultBaseOptions } from './types';
 export declare function getVault({ vault, loans, allocations, options, loadSubaccounts, loadSnapshots, }: {
     vault: IAddress;
@@ -60,20 +60,11 @@ export declare function getVaultTvl({ vault, options, historical, }: {
 export declare function getVaultBorrowerHealthFactor({ vault, options, }: {
     vault: IAddress;
     options: IVaultBaseOptions;
-}): Promise<{
-    borrower: IAddress;
-    loan: IAddress;
-    health_factor?: {
-        datetime: string;
-        health_factor: number;
-        id: string;
-        total_collateral_value: number;
-        total_loan_value: number;
-    };
-}[]>;
-export declare function getHealthFactorOfBorrowersByVault({ options, }: {
+}): Promise<IVaultBorrowerHealthFactor[]>;
+export declare function getHealthFactorOfBorrowersByVault({ options, vault, }: {
     options: IVaultBaseOptions;
-}): Promise<{}>;
+    vault?: IAddress;
+}): Promise<Record<string, IVaultBorrowerHealthFactor[]>>;
 export declare function getUserPoints({ userAddress, options, }: {
     userAddress: IAddress;
     options?: IVaultBaseOptions;

package/lib/modules/vaults/getters.js

@@ -1281,7 +1281,7 @@ async function getVaultTvl({ vault, options, historical, }) {
 async function getVaultBorrowerHealthFactor({ vault, options, }) {
     const provider = (0, core_1.createProvider)(options.rpcUrl);
     const loans = await getVaultLoans(vault, options);
-    const activeLoans = (await Promise.all(loans.map(async (l) => {
+    const activeLoanResults = await Promise.allSettled(loans.map(async (l) => {
         const loanContract = (0, core_1.createContract)({
             provider,
             address: l.address,
@@ -1289,10 +1289,21 @@ async function getVaultBorrowerHealthFactor({ vault, options, }) {
         });
         const loanState = await loanContract.loanState();
         if ((0, core_1.loanStateToReadable)(loanState) !== 'ACTIVE')
-            return;
+            return undefined;
         return l.address;
-    }))).filter((l) => l !== undefined);
-    const formattedLoansArray = await Promise.all(activeLoans.map(async (l) => {
+    }));
+    const activeLoans = activeLoanResults
+        .map((r, i) => {
+        if (r.status === 'fulfilled')
+            return r.value;
+        core_1.Logger.log.warn('getVaultBorrowerHealthFactor:loanState', r.reason, {
+            vault,
+            loan: loans[i]?.address,
+        });
+        return undefined;
+    })
+        .filter((l) => l !== undefined);
+    const formattedSettled = await Promise.allSettled(activeLoans.map(async (l) => {
         const loanContract = (0, core_1.createContract)({
             provider,
             address: l,
@@ -1303,32 +1314,62 @@ async function getVaultBorrowerHealthFactor({ vault, options, }) {
             loan: l,
         };
     }));
+    const formattedLoansArray = formattedSettled
+        .map((r, i) => {
+        if (r.status === 'fulfilled')
+            return r.value;
+        core_1.Logger.log.warn('getVaultBorrowerHealthFactor:borrower', r.reason, {
+            vault,
+            loan: activeLoans[i],
+        });
+        return undefined;
+    })
+        .filter((entry) => entry !== undefined);
     const uniqueBorrowers = [
         ...new Set(formattedLoansArray.map((l) => l.borrower)),
     ];
     const borrowerResponses = {};
     for (const b of uniqueBorrowers) {
-        const response = await (0, core_1.fetchAugustWithKey)(options.augustKey, core_1.WEBSERVER_ENDPOINTS.subaccount.health_factor(b));
-        if (response.status === 200) {
-            borrowerResponses[b] = await response.json();
+        try {
+            const response = await (0, core_1.fetchAugustWithKey)(options.augustKey, core_1.WEBSERVER_ENDPOINTS.subaccount.health_factor(b));
+            if (response.status === 200) {
+                borrowerResponses[b] = await response.json();
+            }
+        }
+        catch (err) {
+            core_1.Logger.log.warn('getVaultBorrowerHealthFactor:health_factor', err, {
+                vault,
+                borrower: b,
+            });
         }
     }
-    formattedLoansArray?.map((loan) => {
+    formattedLoansArray.forEach((loan) => {
         loan.health_factor = borrowerResponses[loan.borrower];
     });
     return formattedLoansArray;
 }
-async function getHealthFactorOfBorrowersByVault({ options, }) {
-    const vaults = await (0, core_1.fetchTokenizedVaults)(undefined, options?.headers, false, false);
-    const healthFactors = await Promise.all(vaults.map(async (v) => {
+async function getHealthFactorOfBorrowersByVault({ options, vault, }) {
+    const vaults = vault
+        ? ((await (0, core_1.fetchTokenizedVault)(vault, options?.headers)) ?? [])
+        : await (0, core_1.fetchTokenizedVaults)(undefined, options?.headers, false, false);
+    const healthFactorResults = await Promise.allSettled(vaults.map(async (v) => {
         return getVaultBorrowerHealthFactor({
             vault: v.address,
             options,
         });
     }));
     const healthFactorsByPool = {};
-    vaults.map((pool, index) => {
-        healthFactorsByPool[pool.address] = healthFactors[index];
+    vaults.forEach((pool, index) => {
+        const result = healthFactorResults[index];
+        const key = pool.address.toLowerCase();
+        if (result?.status === 'fulfilled') {
+            healthFactorsByPool[key] = result.value;
+            return;
+        }
+        core_1.Logger.log.warn('getHealthFactorOfBorrowersByVault:vault', result?.reason, {
+            vault: pool.address,
+        });
+        healthFactorsByPool[key] = [];
     });
     return healthFactorsByPool;
 }

package/lib/modules/vaults/main.d.ts

@@ -125,7 +125,7 @@ export declare class AugustVaults extends AugustBase {
         vault: IAddress;
         chainId?: IChainId;
     }): Promise<number>;
-    getVaultBorrowerHealthFactor(chainId?: IChainId): Promise<{}>;
+    getVaultBorrowerHealthFactor(chainId?: IChainId, vault?: IAddress): Promise<Record<string, import("../../types").IVaultBorrowerHealthFactor[]> | Record<string, import("../../types").IVaultBorrowerHealthFactor[]>[]>;
     getUserPoints(userAddress: IAddress): Promise<any>;
     registerUserForPoints(userAddress: IAddress, referrerAddress: IAddress | undefined, chainId: number, signature: string, nonce: string, expiry: number): Promise<Response>;
     fetchPointsLeaderboard(params?: {

package/lib/modules/vaults/main.js

@@ -740,7 +740,7 @@ class AugustVaults extends core_1.AugustBase {
             },
         });
     }
-    async getVaultBorrowerHealthFactor(chainId) {
+    async getVaultBorrowerHealthFactor(chainId, vault) {
         if (chainId) {
             const health_factors = await (0, getters_1.getHealthFactorOfBorrowersByVault)({
                 options: {
@@ -748,6 +748,7 @@ class AugustVaults extends core_1.AugustBase {
                     env: this.monitoring?.env,
                     augustKey: this.keys?.august,
                 },
+                vault,
             });
             return health_factors;
         }
@@ -763,6 +764,7 @@ class AugustVaults extends core_1.AugustBase {
                     subgraphKey: this.keys?.graph,
                     headers: this.headers,
                 },
+                vault,
             });
         }));
         return health_factors.flat();

package/lib/modules/vaults/write.actions.d.ts

@@ -1,5 +1,6 @@
 import { Signer, Wallet, TransactionResponse } from 'ethers';
 import { IAddress } from '../../types';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
 export type IContractWriteOptions = {
     target: IAddress;
     wallet: IAddress;
@@ -10,6 +11,8 @@ export type IContractWriteOptions = {
     poolName?: string;
     isInstantRedeem?: boolean;
     isDepositWithPermit?: boolean;
+    receiver?: IAddress;
+    slippageBps?: number;
 };
 export type INativeDepositOptions = {
     wrapperAddress: IAddress;
@@ -31,6 +34,7 @@ export declare function resolveSpender(args: {
     isMultiAssetVault: boolean;
     isAdapterDeposit: boolean;
     adapterWrapperAddress?: IAddress;
+    swapRouterAddress?: IAddress;
 }): IAddress;
 export declare function validateAmountPrecision(amount: string | bigint | number): void;
 export declare function isNonceParsing(error: unknown): boolean;
@@ -71,3 +75,6 @@ export type IRwaRedeemOptions = {
     wait?: boolean;
 };
 export declare function rwaRedeemAsset(signer: Signer | Wallet, options: IRwaRedeemOptions): Promise<string>;
+export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAndDepositOptions): Promise<string>;
+export declare function depositViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterDirectDepositOptions): Promise<string>;
+export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterNativeDepositOptions): Promise<string>;