@kamino-finance/klend-sdk 5.0.3 → 5.0.4

package/src/leverage/types.ts

@@ -0,0 +1,211 @@
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import Decimal from 'decimal.js';
+import { KaminoMarket, KaminoObligation } from '../classes';
+import { InstructionsWithLookupTables, Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
+import { ObligationType, ObligationTypeTag } from '../utils';
+
+export type SwapQuoteProvider<QuoteResponse> = (
+  inputs: SwapInputs,
+  klendAccounts: Array<PublicKey>
+) => Promise<SwapQuote<QuoteResponse>>;
+
+export type SwapQuoteIxsProvider<QuoteResponse> = (
+  inputs: SwapInputs,
+  klendAccounts: Array<PublicKey>,
+  quote: SwapQuote<QuoteResponse>
+) => Promise<SwapQuoteIxs>;
+
+export type SwapQuote<QuoteResponse> = {
+  priceAInB: Decimal;
+  quoteResponse?: QuoteResponse;
+};
+
+export type SwapQuoteIxs = {
+  preActionIxs: TransactionInstruction[];
+  swapIxs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
+};
+
+export type PriceAinBProvider = (mintA: PublicKey, mintB: PublicKey) => Promise<Decimal>;
+
+export type IsKtokenProvider = (token: PublicKey | string) => Promise<boolean>;
+
+export type SwapInputs = {
+  inputAmountLamports: Decimal;
+  inputMint: PublicKey;
+  outputMint: PublicKey;
+  amountDebtAtaBalance: Decimal | undefined;
+};
+
+export type KaminoDepositSwapOverride = (
+  kaminoMarket: KaminoMarket,
+  kamino: Kamino,
+  depositor: PublicKey,
+  amountInMint: PublicKey,
+  amountOutMint: PublicKey,
+  amountIn: Decimal,
+  slippageFactor: Decimal,
+  amountDebtAtaBalance: Decimal
+) => Promise<InstructionsWithLookupTables>;
+
+export type DepsoitLeverageIxsResponse<QuoteResponse> = {
+  ixs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
+  swapInputs: SwapInputs;
+  initialInputs: DepositLeverageInitialInputs<QuoteResponse>;
+};
+
+export type DepositLeverageInitialInputs<QuoteResponse> = {
+  calcs: DepositLeverageCalcsResult;
+  swapQuote: SwapQuote<QuoteResponse>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
+  collIsKtoken: boolean;
+  obligation: KaminoObligation | ObligationType | undefined;
+  strategy: StrategyWithAddress | undefined;
+};
+
+export interface DepositWithLeverageSwapInputsProps<QuoteResponse> {
+  owner: PublicKey;
+  kaminoMarket: KaminoMarket;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  obligation: KaminoObligation | null;
+  obligationTypeTagOverride: ObligationTypeTag;
+  referrer: PublicKey;
+  currentSlot: number;
+  depositAmount: Decimal;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  targetLeverage: Decimal;
+  selectedTokenMint: PublicKey;
+  budgetAndPriorityFeeIxs?: TransactionInstruction[];
+  kamino: Kamino | undefined;
+  scopeFeed: string | undefined;
+  quoteBufferBps: Decimal;
+  priceAinB: PriceAinBProvider;
+  isKtoken: IsKtokenProvider;
+  quoter: SwapQuoteProvider<QuoteResponse>;
+}
+
+export interface DepositWithLeverageProps<QuoteResponse> extends DepositWithLeverageSwapInputsProps<QuoteResponse> {
+  swapper: SwapQuoteIxsProvider<QuoteResponse>;
+}
+
+export type DepositLeverageCalcsResult = {
+  flashBorrowInCollToken: Decimal;
+  initDepositInSol: Decimal;
+  debtTokenToBorrow: Decimal;
+  collTokenToDeposit: Decimal;
+  swapDebtTokenIn: Decimal;
+  swapCollTokenExpectedOut: Decimal;
+  flashBorrowInDebtTokenKtokenOnly: Decimal;
+  singleSidedDepositKtokenOnly: Decimal;
+  requiredCollateralKtokenOnly: Decimal;
+};
+
+export type WithdrawLeverageIxsResponse<QuoteResponse> = {
+  ixs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
+  swapInputs: SwapInputs;
+  initialInputs: WithdrawLeverageInitialInputs<QuoteResponse>;
+};
+
+export type WithdrawLeverageInitialInputs<QuoteResponse> = {
+  calcs: WithdrawLeverageCalcsResult;
+  swapQuote: SwapQuote<QuoteResponse>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
+  collIsKtoken: boolean;
+  obligation: KaminoObligation | ObligationType | undefined;
+  strategy: StrategyWithAddress | undefined;
+};
+
+export interface WithdrawWithLeverageSwapInputsProps<QuoteResponse> {
+  owner: PublicKey;
+  kaminoMarket: KaminoMarket;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  obligation: KaminoObligation;
+  deposited: Decimal;
+  borrowed: Decimal;
+  referrer: PublicKey;
+  currentSlot: number;
+  withdrawAmount: Decimal;
+  priceCollToDebt: Decimal;
+  slippagePct: Decimal;
+  isClosingPosition: boolean;
+  selectedTokenMint: PublicKey;
+  budgetAndPriorityFeeIxs?: TransactionInstruction[];
+  kamino: Kamino | undefined;
+  scopeFeed: string | undefined;
+  quoteBufferBps: Decimal;
+  isKtoken: IsKtokenProvider;
+  quoter: SwapQuoteProvider<QuoteResponse>;
+}
+
+export interface WithdrawWithLeverageProps<QuoteResponse> extends WithdrawWithLeverageSwapInputsProps<QuoteResponse> {
+  swapper: SwapQuoteIxsProvider<QuoteResponse>;
+}
+
+export type WithdrawLeverageCalcsResult = {
+  withdrawAmount: Decimal;
+  repayAmount: Decimal;
+  collTokenSwapIn: Decimal;
+  depositTokenWithdrawAmount: Decimal;
+  debtTokenExpectedSwapOut: Decimal;
+};
+
+export type AdjustLeverageIxsResponse<QuoteResponse> = {
+  ixs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
+  swapInputs: SwapInputs;
+  initialInputs: AdjustLeverageInitialInputs<QuoteResponse>;
+};
+
+export type AdjustLeverageInitialInputs<QuoteResponse> = {
+  calcs: AdjustLeverageCalcsResult;
+  swapQuote: SwapQuote<QuoteResponse>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
+  isDeposit: boolean;
+  collIsKtoken: boolean;
+  obligation: KaminoObligation | ObligationType | undefined;
+  strategy: StrategyWithAddress | undefined;
+};
+
+export interface AdjustLeverageSwapInputsProps<QuoteResponse> {
+  owner: PublicKey;
+  kaminoMarket: KaminoMarket;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  obligation: KaminoObligation;
+  depositedLamports: Decimal;
+  borrowedLamports: Decimal;
+  referrer: PublicKey;
+  currentSlot: number;
+  targetLeverage: Decimal;
+  priceCollToDebt: Decimal;
+  priceDebtToColl: Decimal;
+  slippagePct: Decimal;
+  budgetAndPriorityFeeIxs?: TransactionInstruction[];
+  kamino: Kamino | undefined;
+  scopeFeed: string | undefined;
+  quoteBufferBps: Decimal;
+  priceAinB: PriceAinBProvider;
+  isKtoken: IsKtokenProvider;
+  quoter: SwapQuoteProvider<QuoteResponse>;
+}
+
+export interface AdjustLeverageProps<QuoteResponse> extends AdjustLeverageSwapInputsProps<QuoteResponse> {
+  swapper: SwapQuoteIxsProvider<QuoteResponse>;
+}
+
+export type AdjustLeverageCalcsResult = {
+  adjustDepositPosition: Decimal;
+  adjustBorrowPosition: Decimal;
+  amountToFlashBorrowDebt: Decimal;
+  borrowAmount: Decimal;
+  expectedDebtTokenAtaBalance: Decimal;
+  withdrawAmountWithSlippageAndFlashLoanFee: Decimal;
+};

package/src/leverage/utils.ts

@@ -1,11 +1,11 @@
 import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
 import { KaminoMarket, KaminoReserve, lamportsToNumberDecimal } from '../classes';
 import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { PriceAinBProvider, SwapIxnsProvider } from './operations';
 import Decimal from 'decimal.js';
-import { getTokenAccountBalanceDecimal } from '../utils';
+import { getLookupTableAccounts, getTokenAccountBalanceDecimal } from '../utils';
 import { numberToLamportsDecimal } from '../classes/utils';
 import BN from 'bn.js';
+import { PriceAinBProvider, SwapInputs, SwapQuote, SwapQuoteIxs, SwapQuoteIxsProvider } from './types';
 
 export interface KaminoSwapperIxBuilder {
   (
@@ -25,48 +25,55 @@ export interface DepositAmountsForSwap {
   tokenBToSwapAmount: Decimal;
 }
 
-export const getTokenToKtokenSwapper = async (
-  connection: Connection,
+export async function getTokenToKtokenSwapper<QuoteResponse>(
   kaminoMarket: KaminoMarket,
   kamino: Kamino,
   depositor: PublicKey,
-  swapper: SwapIxnsProvider,
+  slippagePct: Decimal,
+  swapper: SwapQuoteIxsProvider<QuoteResponse>,
   priceAinB: PriceAinBProvider,
   includeAtaIxns: boolean = true
-): Promise<SwapIxnsProvider> => {
+): Promise<SwapQuoteIxsProvider<QuoteResponse>> {
   return async (
-    amountInLamports: number,
-    amountInMint: PublicKey,
-    amountOutMint: PublicKey,
-    slippage: number,
-    amountDebtAtaBalance?: Decimal
-  ) => {
-    const slippageBps = new Decimal(slippage).mul('100');
-    const mintInDecimals = kaminoMarket.getReserveByMint(amountInMint)!.state.liquidity.mintDecimals.toNumber();
-    const amountIn = lamportsToNumberDecimal(amountInLamports, mintInDecimals);
-    console.debug('Depositing token', amountInMint.toString(), ' for ', amountOutMint.toString(), 'ktoken');
-    if (amountDebtAtaBalance === undefined) {
+    inputs: SwapInputs,
+    klendAccounts: Array<PublicKey>,
+    quote: SwapQuote<QuoteResponse>
+  ): Promise<SwapQuoteIxs> => {
+    const slippageBps = new Decimal(slippagePct).mul('100');
+    const mintInDecimals = kaminoMarket.getReserveByMint(inputs.inputMint)!.state.liquidity.mintDecimals.toNumber();
+    const amountIn = lamportsToNumberDecimal(inputs.inputAmountLamports, mintInDecimals);
+    console.debug('Depositing token', inputs.inputMint.toString(), ' for ', inputs.outputMint.toString(), 'ktoken');
+    if (inputs.amountDebtAtaBalance === undefined) {
       throw Error('Amount in debt ATA balance is undefined for leverage ktoken deposit');
     }
 
     const ixWithLookup = (await getKtokenDepositIxs(
-      connection,
+      kaminoMarket.getConnection(),
       kamino,
       depositor,
-      amountInMint,
-      amountOutMint,
+      inputs.inputMint,
+      inputs.outputMint,
       amountIn,
       slippageBps,
-      amountDebtAtaBalance,
+      inputs.amountDebtAtaBalance,
       swapper,
       priceAinB,
-      includeAtaIxns
+      includeAtaIxns,
+      klendAccounts,
+      quote
     ))!;
-    return [ixWithLookup.instructions, ixWithLookup.lookupTablesAddresses];
+
+    const luts = await getLookupTableAccounts(kaminoMarket.getConnection(), ixWithLookup.lookupTablesAddresses);
+
+    return {
+      preActionIxs: [],
+      swapIxs: ixWithLookup.instructions,
+      lookupTables: luts,
+    };
   };
-};
+}
 
-export async function getKtokenDepositIxs(
+export async function getKtokenDepositIxs<QuoteResponse>(
   connection: Connection,
   kamino: Kamino,
   depositor: PublicKey,
@@ -75,9 +82,11 @@ export async function getKtokenDepositIxs(
   amountToDeposit: Decimal,
   slippageBps: Decimal,
   amountExpectedDepositAtaBalance: Decimal,
-  swapper: SwapIxnsProvider,
+  swapper: SwapQuoteIxsProvider<QuoteResponse>,
   priceAinB: PriceAinBProvider,
-  includeAtaIxns: boolean = true
+  includeAtaIxns: boolean = true,
+  klendAccounts: Array<PublicKey>,
+  quote: SwapQuote<QuoteResponse>
 ) {
   const kaminoStrategy = await kamino.getStrategyByKTokenMint(ktokenMint);
   const tokenAMint = kaminoStrategy?.strategy.tokenAMint!;
@@ -94,7 +103,7 @@ export async function getKtokenDepositIxs(
       depositor,
       slippageBps,
       undefined,
-      swapProviderToKaminoSwapProvider(swapper),
+      swapProviderToKaminoSwapProvider(swapper, klendAccounts, quote),
       tokensBalances,
       priceAinBDecimal,
       includeAtaIxns
@@ -108,7 +117,7 @@ export async function getKtokenDepositIxs(
       depositor,
       slippageBps,
       undefined,
-      swapProviderToKaminoSwapProvider(swapper),
+      swapProviderToKaminoSwapProvider(swapper, klendAccounts, quote),
       tokensBalances,
       priceAinBDecimal,
       includeAtaIxns
@@ -118,18 +127,18 @@ export async function getKtokenDepositIxs(
   }
 }
 
-export const getKtokenToTokenSwapper = async (
+export async function getKtokenToTokenSwapper<QuoteResponse>(
   kaminoMarket: KaminoMarket,
   kamino: Kamino,
   depositor: PublicKey,
-  swapper: SwapIxnsProvider
-): Promise<SwapIxnsProvider> => {
-  return async (amountInLamports: number, amountInMint: PublicKey, amountOutMint: PublicKey, slippage: number) => {
-    const amountInDecimals = kaminoMarket.getReserveByMint(amountInMint)!.state.liquidity.mintDecimals.toNumber();
-    const amountToWithdraw = lamportsToNumberDecimal(amountInLamports, amountInDecimals);
-    const kaminoStrategy = await kamino.getStrategyByKTokenMint(amountInMint);
+  swapper: SwapQuoteIxsProvider<QuoteResponse>
+): Promise<SwapQuoteIxsProvider<QuoteResponse>> {
+  return async (inputs: SwapInputs, klendAccounts: Array<PublicKey>, quote: SwapQuote<QuoteResponse>) => {
+    const amountInDecimals = kaminoMarket.getReserveByMint(inputs.inputMint)!.state.liquidity.mintDecimals.toNumber();
+    const amountToWithdraw = lamportsToNumberDecimal(inputs.inputAmountLamports, amountInDecimals);
+    const kaminoStrategy = await kamino.getStrategyByKTokenMint(inputs.inputMint);
 
-    console.log('Withdrawing ktoken', amountInMint.toString(), ' for ', amountOutMint.toString(), 'token');
+    console.log('Withdrawing ktoken', inputs.inputMint.toString(), ' for ', inputs.outputMint.toString(), 'token');
 
     const ixWithdraw = (await getKtokenWithdrawIxs(kamino, depositor, kaminoStrategy!, amountToWithdraw))!;
 
@@ -139,29 +148,45 @@ export const getKtokenToTokenSwapper = async (
       amountToWithdraw
     );
 
-    if (amountOutMint.equals(kaminoStrategy?.strategy.tokenAMint!)) {
-      const [swapIxs, swapLookupTables] = await swapper(
-        estimatedBOut.toNumber(),
-        kaminoStrategy?.strategy.tokenBMint!,
-        kaminoStrategy?.strategy.tokenAMint!,
-        slippage
+    if (inputs.outputMint.equals(kaminoStrategy!.strategy.tokenAMint!)) {
+      const { swapIxs, lookupTables } = await swapper(
+        {
+          inputAmountLamports: estimatedBOut,
+          inputMint: kaminoStrategy!.strategy.tokenBMint!,
+          outputMint: kaminoStrategy!.strategy.tokenAMint!,
+          amountDebtAtaBalance: new Decimal(0),
+        },
+        klendAccounts,
+        quote
       );
 
-      return [[...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swapIxs], swapLookupTables];
-    } else if (amountOutMint.equals(kaminoStrategy?.strategy.tokenBMint!)) {
-      const [swapIxs, swapLookupTables] = await swapper(
-        estimatedAOut.toNumber(),
-        kaminoStrategy?.strategy.tokenAMint!,
-        kaminoStrategy?.strategy.tokenBMint!,
-        slippage
+      return {
+        preActionIxs: [],
+        swapIxs: [...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swapIxs],
+        lookupTables,
+      };
+    } else if (inputs.outputMint.equals(kaminoStrategy!.strategy.tokenBMint!)) {
+      const { swapIxs, lookupTables } = await swapper(
+        {
+          inputAmountLamports: estimatedAOut,
+          inputMint: kaminoStrategy!.strategy.tokenAMint!,
+          outputMint: kaminoStrategy!.strategy.tokenBMint!,
+          amountDebtAtaBalance: new Decimal(0),
+        },
+        klendAccounts,
+        quote
       );
 
-      return [[...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swapIxs], swapLookupTables];
+      return {
+        preActionIxs: [],
+        swapIxs: [...ixWithdraw.prerequisiteIxs, ixWithdraw.withdrawIx, ...swapIxs],
+        lookupTables,
+      };
     } else {
       throw Error('Deposit token is neither A nor B in the strategy');
     }
   };
-};
+}
 
 export async function getKtokenWithdrawIxs(
   kamino: Kamino,
@@ -225,29 +250,43 @@ export async function getKtokenWithdrawEstimatesAndPrice(
   return [estimatedAOutDecimal, estimatedBOutDecimal];
 }
 
-export function swapProviderToKaminoSwapProvider(swapper: SwapIxnsProvider): KaminoSwapperIxBuilder {
+export function swapProviderToKaminoSwapProvider<QuoteResponse>(
+  swapper: SwapQuoteIxsProvider<QuoteResponse>,
+  klendAccounts: Array<PublicKey>,
+  swapQuote: SwapQuote<QuoteResponse>
+): KaminoSwapperIxBuilder {
   return async (
     input: DepositAmountsForSwap,
     tokenAMint: PublicKey,
     tokenBMint: PublicKey,
     _owner: PublicKey,
-    slippageBps: Decimal,
+    _slippage: Decimal,
     _allKeys: PublicKey[]
   ): Promise<[TransactionInstruction[], PublicKey[]]> => {
     if (input.tokenBToSwapAmount.lt(0)) {
-      return await swapper(
-        input.tokenBToSwapAmount.abs().toNumber(),
-        tokenBMint,
-        tokenAMint,
-        slippageBps.toNumber() / 100
+      const swapperIxs = await swapper(
+        {
+          inputAmountLamports: input.tokenBToSwapAmount.abs(),
+          inputMint: tokenBMint,
+          outputMint: tokenAMint,
+          amountDebtAtaBalance: undefined,
+        },
+        klendAccounts,
+        swapQuote
       );
+      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.key)];
     } else if (input.tokenAToSwapAmount.lt(0)) {
-      return await swapper(
-        input.tokenAToSwapAmount.abs().toNumber(),
-        tokenAMint,
-        tokenBMint,
-        slippageBps.toNumber() / 100
+      const swapperIxs = await swapper(
+        {
+          inputAmountLamports: input.tokenAToSwapAmount.abs(),
+          inputMint: tokenAMint,
+          outputMint: tokenBMint,
+          amountDebtAtaBalance: undefined,
+        },
+        klendAccounts,
+        swapQuote
       );
+      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.key)];
     } else {
       throw Error('Nothing to swap');
     }

package/src/utils/ObligationType.ts

@@ -24,7 +24,6 @@ export class VanillaObligation {
   constructor(programId: PublicKey) {
     this.programId = programId;
   }
-
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: VanillaObligation.tag,
@@ -35,7 +34,6 @@ export class VanillaObligation {
 
     return initObligationArgs;
   }
-
   toPda(market: PublicKey, user: PublicKey) {
     return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
   }
@@ -63,7 +61,6 @@ export class MultiplyObligation {
 
     return initObligationArgs;
   }
-
   toPda(market: PublicKey, user: PublicKey) {
     return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
   }
@@ -91,7 +88,6 @@ export class LeverageObligation {
 
     return initObligationArgs;
   }
-
   toPda(market: PublicKey, user: PublicKey) {
     return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
   }
@@ -106,7 +102,6 @@ export class LendingObligation {
     this.token = token;
     this.programId = programId;
   }
-
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: LendingObligation.tag,
@@ -117,7 +112,6 @@ export class LendingObligation {
 
     return initObligationArgs;
   }
-
   toPda(market: PublicKey, user: PublicKey) {
     return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
   }

package/src/utils/constants.ts

@@ -73,6 +73,8 @@ export const MIN_AUTODELEVERAGE_BONUS_BPS = 50;
  */
 export const WRAPPED_SOL_MINT = new PublicKey('So11111111111111111111111111111111111111112');
 
+export const SOL_DECIMALS = 9;
+
 /**
  * USDC Mint
  */

package/src/utils/fuzz.ts

@@ -0,0 +1,5 @@
+import Decimal from 'decimal.js';
+
+export function fuzzyEqual(a: Decimal.Value, b: Decimal.Value, epsilon = 0.0001) {
+  return new Decimal(a).sub(b).abs().lte(epsilon);
+}

package/src/utils/index.ts

@@ -12,3 +12,4 @@ export * from './oracle';
 export * from './lookupTable';
 export * from './sendTransactionsUtils';
 export * from './managerTypes';
+export * from './fuzz';

package/src/utils/managerTypes.ts

@@ -49,7 +49,6 @@ export interface AssetConfig {
   assetReserveConfigParams: AssetReserveConfigParams;
 
   setAssetConfigParams(assetReserveConfigParams: AssetReserveConfigParams): void;
-
   getReserveConfig(): ReserveConfig;
 }
 

package/src/utils/pubkey.ts

@@ -239,7 +239,6 @@ export class PubkeyHashMap<K extends PublicKey, V> implements Map<K, V> {
 export class HashablePublicKey extends PublicKey implements IEquality<HashablePublicKey> {
   // We only use the last 32 bits of the public key for hashing
   static MASK = new BN(1).shln(32).subn(1);
-
   constructor(value: PublicKey | string | Buffer | Uint8Array | Array<number>) {
     super(value);
   }
@@ -258,6 +257,5 @@ export class HashablePublicKey extends PublicKey implements IEquality<HashablePu
 
 interface IEquality<T extends IEquality<T>> {
   equals(other: T): boolean;
-
   hashCode(): number;
 }

package/src/utils/rpc.ts

@@ -10,7 +10,6 @@ import {
 import { Buffer } from 'buffer';
 import axios from 'axios';
 import { init, decompress } from '@bokuweb/zstd-wasm';
-
 (async () => {
   await init();
 })();