@kamino-finance/klend-sdk 6.1.0-beta.0 → 7.0.1

package/src/manager/tx/ManagerConnectionPool.ts

@@ -0,0 +1,55 @@
+import {
+  createSolanaRpcSubscriptions,
+  Rpc,
+  RpcSubscriptions,
+  SolanaRpcApi,
+  SolanaRpcSubscriptionsApi,
+} from '@solana/kit';
+import { Connection } from '@solana/web3.js';
+import { Chain, createCliRpc } from './rpc';
+
+export class ManagerConnectionPool {
+  private readonly _rpc: Rpc<SolanaRpcApi>;
+
+  private readonly _wsRpc: RpcSubscriptions<SolanaRpcSubscriptionsApi>;
+
+  private readonly _chain: Chain;
+
+  private readonly _legacyConnection: Connection;
+
+  private readonly _spam: boolean;
+
+  constructor(chain: Chain) {
+    this._chain = chain;
+
+    this._rpc = createCliRpc(chain);
+
+    this._wsRpc = createSolanaRpcSubscriptions(this.chain.wsEndpoint.url);
+
+    this._legacyConnection = new Connection(this.chain.endpoint.url, {
+      commitment: 'processed',
+    });
+
+    this._spam = chain.name !== 'localnet';
+  }
+
+  get chain(): Chain {
+    return this._chain;
+  }
+
+  get rpc(): Rpc<SolanaRpcApi> {
+    return this._rpc;
+  }
+
+  get wsRpc(): RpcSubscriptions<SolanaRpcSubscriptionsApi> {
+    return this._wsRpc;
+  }
+
+  get legacyConnection(): Connection {
+    return this._legacyConnection;
+  }
+
+  get shouldSpam(): boolean {
+    return this._spam;
+  }
+}

package/src/manager/tx/ManagerEnv.ts

@@ -0,0 +1,211 @@
+import { address, Address, TransactionSigner } from '@solana/kit';
+import { ManagerConnectionPool } from './ManagerConnectionPool';
+import { PROGRAM_ID as KLEND_PROGRAM_ID } from '../../@codegen/klend/programId';
+import { PROGRAM_ID as KVAULT_PROGRAM_ID } from '../../@codegen/kvault/programId';
+import { PROGRAM_ID as FARMS_PROGRAM_ID } from '@kamino-finance/farms-sdk/dist/@codegen/farms/programId';
+import { STAGING_PROGRAM_ID as KLEND_STAGING_PROGRAM_ID } from '../../utils/constants';
+import { noopSigner, parseKeypairFile } from './keypair';
+import { Chain } from './rpc';
+import { KaminoMarket } from '../../classes';
+import { FARMS_GLOBAL_CONFIG_MAINNET } from '../../classes/farm_utils';
+import { KVAULT_STAGING_PROGRAM_ID } from '../utils/consts';
+import { VaultState } from '../../@codegen/kvault/accounts';
+
+export type Cluster = 'localnet' | 'devnet' | 'mainnet-beta';
+
+export type SendTxMode = 'execute' | 'simulate' | 'multisig' | 'print';
+
+export type SignerConfig = {
+  multisigSigner?: TransactionSigner;
+  admin?: TransactionSigner;
+};
+
+export type ProgramConfig = {
+  staging?: boolean;
+  klendProgramId?: Address;
+  kvaultProgramId?: Address;
+  farmsProgramId?: Address;
+  farmsGlobalConfig?: Address;
+};
+
+interface GetSignerProps {
+  market?: KaminoMarket;
+  useLendingMarketOwnerCached?: boolean;
+  vaultState?: VaultState;
+  useVaultPendingAdmin?: boolean;
+}
+
+export class ManagerEnv {
+  c: ManagerConnectionPool;
+  cluster: Cluster;
+  signerConfig: SignerConfig;
+  klendProgramId: Address;
+  kvaultProgramId: Address;
+  farmsProgramId: Address;
+  farmsGlobalConfig: Address;
+
+  constructor(
+    c: ManagerConnectionPool,
+    cluster: Cluster,
+    signerConfig: SignerConfig,
+    klendProgramId: Address,
+    kvaultProgramId: Address,
+    farmsProgramId: Address,
+    farmsGlobalConfig: Address
+  ) {
+    this.c = c;
+    this.cluster = cluster;
+    this.signerConfig = signerConfig;
+    this.klendProgramId = klendProgramId;
+    this.kvaultProgramId = kvaultProgramId;
+    this.farmsProgramId = farmsProgramId;
+    this.farmsGlobalConfig = farmsGlobalConfig;
+  }
+
+  async getSigner({
+    market,
+    useLendingMarketOwnerCached,
+    vaultState,
+    useVaultPendingAdmin,
+  }: GetSignerProps = {}): Promise<TransactionSigner> {
+    function matchesAdmin(config: SignerConfig, a: Address): boolean {
+      return config.admin !== undefined && config.admin.address === a;
+    }
+
+    if (vaultState) {
+      if (useVaultPendingAdmin) {
+        return matchesAdmin(this.signerConfig, vaultState.pendingAdmin)
+          ? this.signerConfig.admin!
+          : noopSigner(vaultState.vaultAdminAuthority);
+      } else {
+        return matchesAdmin(this.signerConfig, vaultState.vaultAdminAuthority)
+          ? this.signerConfig.admin!
+          : noopSigner(vaultState.vaultAdminAuthority);
+      }
+    } else if (market) {
+      if (useLendingMarketOwnerCached) {
+        return matchesAdmin(this.signerConfig, market.state.lendingMarketOwnerCached)
+          ? this.signerConfig.admin!
+          : noopSigner(market.state.lendingMarketOwnerCached);
+      } else {
+        return matchesAdmin(this.signerConfig, market.state.lendingMarketOwner)
+          ? this.signerConfig.admin!
+          : noopSigner(market.state.lendingMarketOwner);
+      }
+    } else if (this.signerConfig.admin) {
+      return this.signerConfig.admin;
+    } else if (this.signerConfig.multisigSigner) {
+      return this.signerConfig.multisigSigner;
+    }
+    throw new Error(`No signer in config ${JSON.stringify(this.signerConfig)}`);
+  }
+}
+
+function defaultProgramConfig(programConfig: {
+  klendProgramId?: Address | undefined;
+  kvaultProgramId?: Address | undefined;
+  farmsProgramId?: Address | undefined;
+  farmsGlobalConfig?: Address | undefined;
+  staging?: boolean | undefined;
+}): Required<ProgramConfig> {
+  const stagingOpt = programConfig.staging ?? false;
+  const config: Required<ProgramConfig> = {
+    staging: stagingOpt,
+    klendProgramId: programConfig?.klendProgramId ?? (stagingOpt ? KLEND_STAGING_PROGRAM_ID : KLEND_PROGRAM_ID),
+    kvaultProgramId: programConfig.kvaultProgramId ?? (stagingOpt ? KVAULT_STAGING_PROGRAM_ID : KVAULT_PROGRAM_ID),
+    farmsProgramId: programConfig?.farmsProgramId ?? FARMS_PROGRAM_ID,
+    farmsGlobalConfig: programConfig?.farmsGlobalConfig ?? FARMS_GLOBAL_CONFIG_MAINNET,
+  };
+  return config;
+}
+
+export async function initEnv(
+  staging: boolean = false,
+  multisig: Address | undefined = undefined,
+  adminKeypairPath: string | undefined = process.env.ADMIN,
+  rpcUrl: string | undefined = process.env.RPC
+): Promise<ManagerEnv> {
+  const config = defaultProgramConfig({
+    staging,
+    klendProgramId: staging ? envAddress('KLEND_PROGRAM_ID_STAGING') : envAddress('KLEND_PROGRAM_ID_MAINNET'),
+    kvaultProgramId: staging ? envAddress('KVAULT_PROGRAM_ID_STAGING') : envAddress('KVAULT_PROGRAM_ID_MAINNET'),
+  });
+
+  let resolvedUrl: string;
+  if (rpcUrl) {
+    resolvedUrl = rpcUrl;
+  } else {
+    throw 'Must specify an RPC URL';
+  }
+
+  let resolvedAdmin: TransactionSigner | undefined = undefined;
+  if (adminKeypairPath) {
+    resolvedAdmin = await parseKeypairFile(adminKeypairPath);
+  }
+
+  const rpcChain = parseRpcChain(rpcUrl);
+
+  const c = new ManagerConnectionPool(rpcChain);
+  const multisigSigner = multisig ? noopSigner(multisig) : undefined;
+  const env: ManagerEnv = new ManagerEnv(
+    c,
+    rpcChain.name,
+    {
+      admin: resolvedAdmin,
+      multisigSigner,
+    },
+    config.klendProgramId,
+    config.kvaultProgramId,
+    config.farmsProgramId,
+    config.farmsGlobalConfig
+  );
+
+  console.log('\nSettings ⚙️');
+  console.log(`Multisig: ${multisig}`);
+  console.log(`Multisig signer: ${multisigSigner?.address}`);
+  console.log(`Admin: ${resolvedAdmin?.address}`);
+  console.log(`Rpc: ${resolvedUrl}`);
+  console.log(`klendProgramId: ${env.klendProgramId}`);
+  console.log(`kvaultProgramId: ${env.kvaultProgramId}`);
+
+  return env;
+}
+
+function parseRpcChain(rpcUrl: string): Chain {
+  let chain: Chain;
+  if (rpcUrl === 'localnet') {
+    chain = {
+      name: 'localnet',
+      endpoint: {
+        url: 'http://127.0.0.1:8899',
+        name: 'localnet',
+      },
+      wsEndpoint: {
+        name: 'localnet',
+        url: 'ws://127.0.0.1:8900',
+      },
+      multicastEndpoints: [],
+    };
+  } else {
+    chain = {
+      name: 'mainnet-beta',
+      endpoint: {
+        url: rpcUrl,
+        name: 'mainnet-beta',
+      },
+      wsEndpoint: {
+        url: rpcUrl.replace('https:', 'wss:') + '/whirligig',
+        name: 'mainnet-beta-ws',
+      },
+      multicastEndpoints: [],
+    };
+  }
+  return chain;
+}
+
+function envAddress(env: string): Address | undefined {
+  if (process.env[env]) {
+    return address(process.env[env]);
+  }
+  return undefined;
+}

package/src/manager/tx/keypair.ts

@@ -0,0 +1,29 @@
+import {
+  Address,
+  createKeyPairSignerFromBytes,
+  KeyPairSigner,
+  SignatureDictionary,
+  Transaction,
+  TransactionPartialSigner,
+  TransactionPartialSignerConfig,
+  TransactionSigner,
+} from '@solana/kit';
+
+export async function parseKeypairFile(path: string): Promise<KeyPairSigner> {
+  const wallet = Buffer.from(JSON.parse(require('fs').readFileSync(path)));
+  return await createKeyPairSignerFromBytes(wallet);
+}
+
+export function noopSigner(address: Address): TransactionSigner {
+  const signer: TransactionPartialSigner = {
+    address,
+    async signTransactions(
+      _transactions: readonly Transaction[],
+      _config?: TransactionPartialSignerConfig
+    ): Promise<readonly SignatureDictionary[]> {
+      // Return an array of empty SignatureDictionary objects — one per transaction
+      return [];
+    },
+  };
+  return signer;
+}

package/src/manager/tx/multisig.ts

@@ -0,0 +1,47 @@
+import {
+  Account,
+  AddressesByLookupTableAddress,
+  appendTransactionMessageInstructions,
+  compileTransactionMessage,
+  createTransactionMessage,
+  getBase58Decoder,
+  getCompiledTransactionMessageEncoder,
+  IInstruction,
+  pipe,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  TransactionSigner,
+} from '@solana/kit';
+import { INVALID_BUT_SUFFICIENT_FOR_COMPILATION_BLOCKHASH } from './simulate';
+import { AddressLookupTable } from '@solana-program/address-lookup-table';
+import { removeComputeBudgetProgramInstructions } from './priorityFee';
+
+const base58Decoder = getBase58Decoder();
+
+export async function printMultisigTx(
+  payer: TransactionSigner,
+  ixs: IInstruction[],
+  luts: Account<AddressLookupTable>[] = []
+) {
+  const lutsByAddress: AddressesByLookupTableAddress = {};
+  if (luts.length > 0) {
+    for (const acc of luts) {
+      lutsByAddress[acc.address] = acc.data.addresses;
+    }
+  }
+
+  const ixsWithoutBudgetAndAtas = removeComputeBudgetProgramInstructions(ixs);
+
+  const transactionMessage = pipe(
+    createTransactionMessage({ version: 'legacy' }),
+    (tx) => setTransactionMessageFeePayer(payer.address, tx),
+    (tx) => appendTransactionMessageInstructions(ixsWithoutBudgetAndAtas, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(INVALID_BUT_SUFFICIENT_FOR_COMPILATION_BLOCKHASH, tx)
+  );
+
+  const compiled = compileTransactionMessage(transactionMessage);
+  const encodedMessageBytes = getCompiledTransactionMessageEncoder().encode(compiled);
+
+  const base58EncodedMessage = base58Decoder.decode(encodedMessageBytes);
+  console.log('Base58 encoded tx:', base58EncodedMessage);
+}

package/src/manager/tx/priorityFee.ts

@@ -0,0 +1,34 @@
+import { IInstruction } from '@solana/kit';
+import {
+  COMPUTE_BUDGET_PROGRAM_ADDRESS,
+  getSetComputeUnitLimitInstruction,
+  getSetComputeUnitPriceInstruction,
+} from '@solana-program/compute-budget';
+
+const microLamport = 10 ** 6; // 1 lamport
+
+export function getPriorityFeeAndCuIxs({
+  priorityFeeMultiplier,
+  computeUnits = 200_000,
+}: {
+  priorityFeeMultiplier: number;
+  computeUnits?: number;
+}): IInstruction[] {
+  const microLamportsPrioritizationFee = microLamport / computeUnits;
+  return [
+    getSetComputeUnitLimitInstruction({ units: computeUnits }),
+    getSetComputeUnitPriceInstruction({
+      microLamports: Math.round(microLamportsPrioritizationFee * priorityFeeMultiplier),
+    }),
+  ];
+}
+
+export function removeComputeBudgetProgramInstructions(ixs: IInstruction[]): IInstruction[] {
+  const filteredIxs = ixs.filter((ix) => {
+    if (ix.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS) {
+      return false;
+    }
+    return true;
+  });
+  return filteredIxs;
+}

package/src/manager/tx/processor.ts

@@ -0,0 +1,29 @@
+import { ManagerConnectionPool } from './ManagerConnectionPool';
+import { Account, IInstruction, TransactionSigner } from '@solana/kit';
+import { sendAndConfirmTx } from './tx';
+import { printSimulateTx } from './simulate';
+import { printMultisigTx } from './multisig';
+import { SendTxMode } from './ManagerEnv';
+import { AddressLookupTable } from '@solana-program/address-lookup-table';
+
+export async function processTx(
+  c: ManagerConnectionPool,
+  payer: TransactionSigner,
+  ixs: IInstruction[],
+  mode: SendTxMode,
+  luts: Account<AddressLookupTable>[] = []
+): Promise<void> {
+  switch (mode) {
+    case 'execute':
+      await sendAndConfirmTx(c, payer, ixs, luts);
+      break;
+    case 'simulate':
+      await printSimulateTx(c, payer, ixs, luts);
+      break;
+    case 'multisig':
+      await printMultisigTx(payer, ixs, luts);
+      break;
+    case 'print':
+      break;
+  }
+}

package/src/manager/tx/rpc.ts

@@ -0,0 +1,152 @@
+import {
+  createDefaultRpcTransport,
+  createRpc,
+  createSolanaRpcApi,
+  DEFAULT_RPC_CONFIG,
+  Rpc,
+  RpcTransport,
+  SendTransactionApi,
+  SolanaRpcApi,
+  SolanaRpcApiDevnet,
+  SolanaRpcApiMainnet,
+  SolanaRpcApiTestnet,
+} from '@solana/kit';
+import { createHttpTransport } from '@solana/rpc-transport-http';
+import { Mutable } from '../utils/modifiers';
+import { Cluster } from './ManagerEnv';
+
+export type RpcMethodTypes = SolanaRpcApi | SolanaRpcApiDevnet | SolanaRpcApiMainnet | SolanaRpcApiTestnet;
+
+/**
+ * Names of Solana RPC methods that should be multicasted to all configured multicast RPCs.
+ */
+const MULTICASTED_METHOD_NAMES: string[] = ['sendTransaction' as const satisfies keyof SendTransactionApi];
+
+type RpcHeadersConfigParam = Parameters<typeof createHttpTransport>[0]['headers'];
+export type AllowedHttpHeaders = Mutable<RpcHeadersConfigParam>;
+
+export type RpcUrl = {
+  url: string;
+  name: string;
+  headers?: AllowedHttpHeaders;
+};
+
+export type Chain = {
+  name: Cluster;
+  endpoint: RpcUrl;
+  wsEndpoint: RpcUrl;
+  multicastEndpoints: RpcUrl[];
+};
+
+export function createCliRpc<TExtraMethods>(rpcChain: Chain): Rpc<RpcMethodTypes & TExtraMethods> {
+  return asRpc(createResilientRpcCaller(rpcChain));
+}
+
+function createUrlRpcCaller({ url, name, headers }: RpcUrl): RpcCaller {
+  return new LabelledRpcCaller(createDefaultRpcTransport({ url, headers }), name);
+}
+
+function createResilientRpcCaller(rpcChain: Chain): RpcCaller {
+  let resilientRpcCaller: RpcCaller = createUrlRpcCaller(rpcChain.endpoint);
+  if (rpcChain.multicastEndpoints.length > 0) {
+    resilientRpcCaller = new MethodRoutingRpcTransport(
+      resilientRpcCaller,
+      MULTICASTED_METHOD_NAMES,
+      new MulticastingRpcTransport(
+        rpcChain.multicastEndpoints.map((url) => createUrlRpcCaller(url)),
+        resilientRpcCaller
+      )
+    );
+  }
+  return resilientRpcCaller;
+}
+
+function asRpc<TExtraMethods>(rpcCaller: RpcCaller): Rpc<RpcMethodTypes & TExtraMethods> {
+  const api = createSolanaRpcApi<RpcMethodTypes & TExtraMethods>({
+    ...DEFAULT_RPC_CONFIG,
+    defaultCommitment: 'processed',
+  });
+  const transport = asRpcTransport(rpcCaller);
+  return createRpc({ api, transport });
+}
+
+function asRpcTransport(rpcCaller: RpcCaller): RpcTransport {
+  // Despite `ReturnType<RpcTransport>` working fine in all other contexts, it loses its type-inferring powers when
+  // `RpcCaller.call()` is referenced directly (due to not seeing the actual type parameter), forcing this ugly cast:
+  return rpcCaller.call.bind(rpcCaller) as RpcTransport;
+}
+
+/**
+ * A "true" interface wrapping the function interface {@link RpcTransport} (so that a class can implement it).
+ */
+export interface RpcCaller {
+  /**
+   * See {@link RpcTransport}.
+   */
+  call(...args: Parameters<RpcTransport>): ReturnType<RpcTransport>;
+}
+
+class LabelledRpcCaller implements RpcCaller {
+  private readonly transport: RpcTransport;
+  private readonly label: string;
+
+  constructor(transport: RpcTransport, label: string) {
+    this.transport = transport;
+    this.label = label;
+  }
+
+  call(...args: Parameters<RpcTransport>): ReturnType<RpcTransport> {
+    return this.transport(...args);
+  }
+
+  toString(): string {
+    return this.label;
+  }
+}
+
+class MethodRoutingRpcTransport implements RpcCaller {
+  private readonly defaultRpcCaller: RpcCaller;
+  private readonly routedMethodNames: Set<string>;
+  private readonly routedRpcCaller: RpcCaller;
+
+  constructor(defaultRpcCaller: RpcCaller, routedMethodNames: Iterable<string>, routedRpcCaller: RpcCaller) {
+    this.defaultRpcCaller = defaultRpcCaller;
+    this.routedMethodNames = new Set(routedMethodNames);
+    this.routedRpcCaller = routedRpcCaller;
+  }
+
+  call(...args: Parameters<RpcTransport>): ReturnType<RpcTransport> {
+    const methodName = MethodRoutingRpcTransport.resolveMethodName(...args);
+    if (this.routedMethodNames.has(methodName)) {
+      return this.routedRpcCaller.call(...args);
+    }
+    return this.defaultRpcCaller.call(...args);
+  }
+
+  private static resolveMethodName(...args: Parameters<RpcTransport>): string {
+    // Please excuse the ugly introspection, needed only because of the RpcTransport using a private type:
+    return (args[0].payload as { method: string }).method;
+  }
+}
+
+class MulticastingRpcTransport {
+  private readonly multicastRpcCallers: Set<RpcCaller>;
+  private readonly finalRpcCaller: RpcCaller;
+
+  constructor(multicastRpcCallers: Iterable<RpcCaller>, finalRpcCaller: RpcCaller) {
+    this.multicastRpcCallers = new Set(multicastRpcCallers);
+    this.finalRpcCaller = finalRpcCaller;
+  }
+
+  call(...args: Parameters<RpcTransport>): ReturnType<RpcTransport> {
+    for (const multicastRpcCaller of this.multicastRpcCallers) {
+      // Please note the lack of `await` below. This is intended, since we want to fire and forget to all multicast
+      // RPCs. This works in JavaScript (in contrast to e.g. Rust), because `Promise`s here start work when constructed,
+      // not when "polled".
+      multicastRpcCaller
+        .call(...args)
+        .catch((e) => console.log(`Calling multicast RPC ${multicastRpcCaller} failed; ignoring it`, e));
+    }
+    return this.finalRpcCaller.call(...args);
+  }
+}

package/src/manager/tx/simulate.ts

@@ -0,0 +1,73 @@
+import {
+  IInstruction,
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageFeePayer,
+  appendTransactionMessageInstructions,
+  compressTransactionMessageUsingAddressLookupTables,
+  AddressesByLookupTableAddress,
+  setTransactionMessageLifetimeUsingBlockhash,
+  Blockhash,
+  compileTransaction,
+  getBase64EncodedWireTransaction,
+  getCompiledTransactionMessageEncoder,
+  compileTransactionMessage,
+  TransactionSigner,
+  Account,
+} from '@solana/kit';
+import { AddressLookupTable } from '@solana-program/address-lookup-table';
+import { BlockhashWithHeight } from './tx';
+import { ManagerConnectionPool } from './ManagerConnectionPool';
+
+export const INVALID_BUT_SUFFICIENT_FOR_COMPILATION_BLOCKHASH: BlockhashWithHeight = {
+  blockhash: '11111111111111111111111111111111' as Blockhash,
+  lastValidBlockHeight: 0n,
+  slot: 0n,
+};
+
+export async function printSimulateTx(
+  c: ManagerConnectionPool,
+  payer: TransactionSigner,
+  ixs: IInstruction[],
+  luts: Account<AddressLookupTable>[] = []
+) {
+  const lutsByAddress: AddressesByLookupTableAddress = {};
+  if (luts.length > 0) {
+    for (const acc of luts) {
+      lutsByAddress[acc.address] = acc.data.addresses;
+    }
+  }
+
+  const transactionMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayer(payer.address, tx),
+    (tx) => appendTransactionMessageInstructions(ixs, tx),
+    (tx) => compressTransactionMessageUsingAddressLookupTables(tx, lutsByAddress),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(INVALID_BUT_SUFFICIENT_FOR_COMPILATION_BLOCKHASH, tx)
+  );
+
+  const compiledTransaction = compileTransaction(transactionMessage);
+  const wireTransactionBytes = getBase64EncodedWireTransaction(compiledTransaction);
+
+  const compiled = compileTransactionMessage(transactionMessage);
+  const encodedMessageBytes = getCompiledTransactionMessageEncoder().encode(compiled);
+
+  const encodedTxMessage = Buffer.from(encodedMessageBytes).toString('base64');
+
+  const simulationUrl = `https://explorer.solana.com/tx/inspector?message=${encodeURIComponent(
+    encodedTxMessage
+  )}&signatures=${encodeURIComponent(`[${payer.address}]`)}`;
+
+  console.log('Simulation URL:', simulationUrl);
+
+  const res = await c.rpc
+    .simulateTransaction(wireTransactionBytes, {
+      encoding: 'base64',
+      replaceRecentBlockhash: true,
+      sigVerify: false,
+    })
+    .send();
+
+  console.log('Simulate Response:', res);
+  console.log('');
+}