@gearbox-protocol/sdk 10.4.5 → 10.6.0

package/dist/esm/dev/RevolverTransport.js

@@ -1,5 +1,6 @@
 import {
   BaseError,
+  CallExecutionError,
   HttpRequestError,
   http,
   InvalidInputRpcError,
@@ -16,11 +17,11 @@ class NoAvailableTransportsError extends BaseError {
   }
 }
 class RevolverTransport {
-  #transports;
-  #index = 0;
   #config;
-  #rotating = false;
   #requests = /* @__PURE__ */ new WeakMap();
+  #selector;
+  #rotating = false;
+  #isSingle;
   overrides;
   /**
    * Create a new RevolverTransport
@@ -44,9 +45,9 @@ class RevolverTransport {
       ...config,
       shouldRetry: config.shouldRetry ?? defaultShouldRetry
     };
-    this.#transports = config.providers.map(
+    const transports = config.providers.map(
       ({ url, name, cooldown }) => ({
-        provider: name,
+        name,
         transport: http(url, {
           retryCount: config.retryCount,
           retryDelay: config.retryDelay,
@@ -60,40 +61,45 @@ class RevolverTransport {
         cooldown: cooldown ?? 0
       })
     );
-    if (this.#transports.length === 0) {
+    if (transports.length === 0) {
       throw new NoAvailableTransportsError();
     }
+    this.#isSingle = transports.length === 1;
+    const selectionStrategy = config.selectionStrategy ?? "simple";
+    this.#selector = selectionStrategy === "simple" ? new SimpleTransportSelector(transports, config.cooldown) : new OrderedTransportSelector(transports, config.cooldown);
   }
   get value() {
     return {
       rotate: (reason) => this.rotate(reason),
-      currentTransportName: () => this.currentTransportName(),
-      statuses: () => this.statuses()
+      currentTransportName: () => this.#selector.transportName(),
+      statuses: () => this.#selector.statuses()
     };
   }
   request = async (r) => {
-    if (this.#transports.length === 1) {
-      return this.#transport({ ...this.overrides }).request(r);
+    if (this.#isSingle) {
+      return this.#selector.select()({
+        ...this.overrides
+      }).request(r);
     }
     let error;
     do {
       try {
-        this.#requests.set(r, this.currentTransportName());
-        const resp = await withRetry(
-          () => this.#transport({ ...this.overrides }).request(r),
-          {
-            delay: this.#config.retryDelay,
-            retryCount: this.#config.retryCount,
-            shouldRetry: this.#config.shouldRetry
-          }
-        );
+        this.#requests.set(r, this.#selector.transportName());
+        const transport = this.#selector.select()({
+          ...this.overrides
+        });
+        const resp = await withRetry(() => transport.request(r), {
+          delay: this.#config.retryDelay,
+          retryCount: this.#config.retryCount,
+          shouldRetry: this.#config.shouldRetry
+        });
         this.#requests.delete(r);
         return resp;
       } catch (e) {
         error = error ?? e;
         if (e instanceof RpcError || e instanceof HttpRequestError) {
           const reqTransport = this.#requests.get(r);
-          if (reqTransport === this.currentTransportName()) {
+          if (reqTransport === this.#selector.transportName()) {
             await this.rotate(e);
           } else {
             this.#logger?.debug(
@@ -105,7 +111,7 @@ class RevolverTransport {
           throw e;
         }
       }
-    } while (this.#hasAvailableTransports);
+    } while (this.#selector.canRotate());
     this.#requests.delete(r);
     throw new NoAvailableTransportsError(error);
   };
@@ -127,82 +133,34 @@ class RevolverTransport {
    * @returns true if rotation was successful
    */
   async rotate(reason) {
-    if (this.#transports.length === 1) {
-      return true;
-    }
     if (this.#rotating) {
       this.#logger?.debug("already rotating, skipping");
-      return false;
+      return;
     }
     this.#rotating = true;
-    this.#logger?.debug(
-      {
-        reason,
-        current: this.currentTransportName,
-        total: this.#transports.length
-      },
-      "rotating transport"
-    );
-    const oldTransportName = this.currentTransportName();
-    const now = Date.now();
-    this.#transports[this.#index].cooldown = now + (this.#config.cooldown ?? 6e4);
-    for (let i = 0; i < this.#transports.length - 1; i++) {
-      this.#index = (this.#index + 1) % this.#transports.length;
-      if (this.#transports[this.#index].cooldown < now) {
-        this.#logger?.info(
-          {
-            current: this.currentTransportName,
-            total: this.#transports.length
-          },
-          "switched to next transport"
-        );
+    const from = this.#selector.transportName();
+    const success = this.#selector.rotate();
+    const to = this.#selector.transportName();
+    if (success) {
+      if (from !== to) {
+        this.#logger?.debug({ from, to, reason }, "transport rotated");
         try {
-          await this.#config.onRotateSuccess?.(
-            oldTransportName,
-            this.currentTransportName(),
-            reason
-          );
+          await this.#config.onRotateSuccess?.(from, to, reason);
         } catch {
         }
-        this.#rotating = false;
-        return true;
-      } else {
-        this.#logger?.warn(
-          {
-            current: this.currentTransportName,
-            total: this.#transports.length
-          },
-          "transport is still on cooldown"
-        );
       }
-    }
-    try {
-      await this.#config.onRotateFailed?.(oldTransportName, reason);
-    } catch {
+    } else {
+      this.#logger?.warn({ from, reason }, "transport rotation failed");
+      try {
+        await this.#config.onRotateFailed?.(from, reason);
+      } catch {
+      }
     }
     this.#rotating = false;
-    return false;
-  }
-  currentTransportName() {
-    return this.#transport({}).config.name;
-  }
-  statuses() {
-    const now = Date.now();
-    return this.#transports.map((t, i) => ({
-      id: t.transport({}).config.name,
-      status: t.cooldown < now ? this.#index === i ? "active" : "standby" : "cooldown"
-    }));
   }
   get #logger() {
     return this.#config.logger;
   }
-  get #transport() {
-    return this.#transports[this.#index].transport;
-  }
-  get #hasAvailableTransports() {
-    const now = Date.now();
-    return this.#transports.some((t) => t.cooldown < now);
-  }
 }
 const retryCodes = /* @__PURE__ */ new Set([
   InvalidRequestRpcError.code,
@@ -214,11 +172,95 @@ const retryCodes = /* @__PURE__ */ new Set([
 const defaultShouldRetry = ({
   error
 }) => {
+  if (error instanceof CallExecutionError && error.details === "header not found") {
+    return true;
+  }
   if ("code" in error && typeof error.code === "number") {
     return retryCodes.has(error.code);
   }
   return false;
 };
+class AbstractTransportSelector {
+  transports;
+  cooldown;
+  index = 0;
+  constructor(transports, cooldown = 6e4) {
+    this.transports = transports;
+    this.cooldown = cooldown;
+  }
+  transportName() {
+    return this.transports[this.index].name;
+  }
+  canRotate() {
+    const now = Date.now();
+    return this.transports.some((t) => t.cooldown < now);
+  }
+  statuses() {
+    const now = Date.now();
+    return this.transports.map((t, i) => ({
+      id: t.name,
+      status: t.cooldown < now ? this.index === i ? "active" : "standby" : "cooldown"
+    }));
+  }
+}
+class SimpleTransportSelector extends AbstractTransportSelector {
+  /**
+   * For simple selector, transport status is not re-evaluated on each request
+   * @returns
+   */
+  select() {
+    return this.transports[this.index].transport;
+  }
+  /**
+   * Simply selects next transport that is not in cooldown by checking all transports in cyclic order
+   * @returns true if rotation was successful
+   */
+  rotate() {
+    if (this.transports.length === 1) {
+      return true;
+    }
+    const now = Date.now();
+    this.transports[this.index].cooldown = now + this.cooldown;
+    for (let i = 0; i < this.transports.length - 1; i++) {
+      this.index = (this.index + 1) % this.transports.length;
+      if (this.transports[this.index].cooldown < now) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+class OrderedTransportSelector extends AbstractTransportSelector {
+  /**
+   * Will select first transport that is not in cooldown
+   * @returns
+   */
+  select() {
+    this.#updateIndex(Date.now());
+    return this.transports[this.index].transport;
+  }
+  /**
+   * Will put current transport into cooldown and select first available transport that is not in cooldown
+   * @returns true if rotation was successful
+   */
+  rotate() {
+    if (this.transports.length === 1) {
+      return true;
+    }
+    const now = Date.now();
+    this.transports[this.index].cooldown = now + this.cooldown;
+    return this.#updateIndex(now);
+  }
+  #updateIndex(now) {
+    for (let i = 0; i < this.transports.length; i++) {
+      if (this.transports[i].cooldown < now) {
+        this.index = i;
+        return true;
+      }
+    }
+    return false;
+  }
+}
 export {
   NoAvailableTransportsError,
   RevolverTransport

package/dist/esm/sdk/market/MarketSuite.js

@@ -1,5 +1,8 @@
 import { SDKConstruct } from "../base/index.js";
 import { CreditSuite } from "./credit/index.js";
+import {
+  createLossPolicy
+} from "./loss-policy/index.js";
 import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import { getOrCreatePriceOracle } from "./oracle/index.js";
 import { PoolSuite } from "./pool/index.js";
@@ -9,6 +12,7 @@ class MarketSuite extends SDKConstruct {
   configurator;
   pool;
   priceOracle;
+  lossPolicy;
   creditManagers = [];
   /**
    * Original data received from compressor
@@ -35,6 +39,7 @@ class MarketSuite extends SDKConstruct {
       this.creditManagers.push(new CreditSuite(sdk, marketData, i));
     }
     this.priceOracle = getOrCreatePriceOracle(sdk, marketData.priceOracle);
+    this.lossPolicy = createLossPolicy(sdk, marketData.lossPolicy);
   }
   get dirty() {
     return this.configurator.dirty || this.pool.dirty || this.priceOracle.dirty || this.creditManagers.some((cm) => cm.dirty);
@@ -54,6 +59,7 @@ class MarketSuite extends SDKConstruct {
       pool: this.pool.stateHuman(raw),
       creditManagers: this.creditManagers.map((cm) => cm.stateHuman(raw)),
       priceOracle: this.priceOracle.stateHuman(raw),
+      lossPolicy: this.lossPolicy.stateHuman(raw),
       pausableAdmins: this.state.pausableAdmins.map((a) => this.labelAddress(a)),
       unpausableAdmins: this.state.unpausableAdmins.map(
         (a) => this.labelAddress(a)

package/dist/esm/sdk/market/credit/CreditFacadeV300Contract.js

@@ -61,7 +61,10 @@ class CreditFacadeV300Contract extends BaseContract {
         break;
     }
   }
-  liquidateCreditAccount(ca, to, calls) {
+  liquidateCreditAccount(ca, to, calls, lossPolicyData) {
+    if (lossPolicyData) {
+      this.logger?.warn("loss policy data is not supported");
+    }
     return this.createRawTx({
       functionName: "liquidateCreditAccount",
       args: [ca, to, calls]

package/dist/esm/sdk/market/credit/CreditFacadeV310Contract.js

@@ -61,10 +61,10 @@ class CreditFacadeV310Contract extends BaseContract {
         break;
     }
   }
-  liquidateCreditAccount(ca, to, calls) {
+  liquidateCreditAccount(ca, to, calls, lossPolicyData) {
     return this.createRawTx({
       functionName: "liquidateCreditAccount",
-      args: [ca, to, calls]
+      args: lossPolicyData ? [ca, to, calls, lossPolicyData] : [ca, to, calls]
     });
   }
   closeCreditAccount(ca, calls) {

package/dist/esm/sdk/market/loss-policy/AliasLossPolicyV310Contract.js

@@ -0,0 +1,16 @@
+import { iAliasedLossPolicyV310Abi } from "../../../abi/310/generated.js";
+import { BaseContract } from "../../base/index.js";
+const abi = iAliasedLossPolicyV310Abi;
+class AliasLossPolicyV310Contract extends BaseContract {
+  constructor(sdk, params) {
+    super(sdk, {
+      abi,
+      addr: params.addr,
+      contractType: params.contractType,
+      version: params.version
+    });
+  }
+}
+export {
+  AliasLossPolicyV310Contract
+};

package/dist/esm/sdk/market/loss-policy/LossPolicyContract.js

@@ -0,0 +1,16 @@
+import { iLossPolicyV310Abi } from "../../../abi/310/generated.js";
+import { BaseContract } from "../../base/index.js";
+const abi = iLossPolicyV310Abi;
+class LossPolicyContract extends BaseContract {
+  constructor(sdk, params) {
+    super(sdk, {
+      abi,
+      addr: params.addr,
+      contractType: params.contractType,
+      version: params.version
+    });
+  }
+}
+export {
+  LossPolicyContract
+};

package/dist/esm/sdk/market/loss-policy/createLossPolicy.js

@@ -0,0 +1,24 @@
+import { bytes32ToString } from "../../index.js";
+import { AliasLossPolicyV310Contract } from "./AliasLossPolicyV310Contract.js";
+import { LossPolicyContract } from "./LossPolicyContract.js";
+function createLossPolicy(sdk, { baseParams }) {
+  const existing = sdk.contracts.get(baseParams.addr);
+  if (existing) {
+    return existing;
+  }
+  const contractType = bytes32ToString(baseParams.contractType);
+  switch (contractType) {
+    case "LOSS_POLICY::ALIASED":
+      return new AliasLossPolicyV310Contract(sdk, baseParams);
+    case "LOSS_POLICY::DEFAULT":
+      return new LossPolicyContract(sdk, baseParams);
+    default:
+      if (sdk.strictContractTypes) {
+        throw new Error(`unsupported loss policy type ${contractType}`);
+      }
+      return new LossPolicyContract(sdk, baseParams);
+  }
+}
+export {
+  createLossPolicy
+};

package/dist/esm/sdk/market/loss-policy/index.js

@@ -0,0 +1,4 @@
+export * from "./AliasLossPolicyV310Contract.js";
+export * from "./createLossPolicy.js";
+export * from "./LossPolicyContract.js";
+export * from "./types.js";