npm - @gearbox-protocol/sdk - Versions diffs - 3.0.0-vfour.65 → 3.0.0-vfour.67 - Mend

@gearbox-protocol/sdk 3.0.0-vfour.65 → 3.0.0-vfour.67

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/cjs/sdk/index.cjs +91 -83
package/dist/cjs/sdk/index.d.ts +315 -6
package/dist/esm/sdk/index.d.mts +315 -6
package/dist/esm/sdk/index.mjs +92 -84
package/package.json +1 -1

package/dist/cjs/sdk/index.cjs CHANGED Viewed

@@ -19152,10 +19152,7 @@ var AddressMap = class {
     this.#map = /* @__PURE__ */ new Map();
     if (entries) {
       for (const [address, value] of entries) {
-        const key = address.toLowerCase();
-        if (!viem.isAddress(key)) {
-          throw new Error(`value "${address}" is not an address`);
-        }
+        const key = viem.getAddress(address);
         this.#map.set(key, value);
       }
     }
@@ -19169,10 +19166,7 @@ var AddressMap = class {
     if (this.#frozen) {
       throw new Error(`AddressMap is frozen`);
     }
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = viem.getAddress(address);
     this.#map.set(key, value);
   }
   /**
@@ -19184,10 +19178,7 @@ var AddressMap = class {
     if (this.#frozen) {
       throw new Error(`AddressMap is frozen`);
     }
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = viem.getAddress(address);
     if (this.#map.has(key)) {
       throw new Error(`address ${address} already exists`);
     }
@@ -19199,10 +19190,7 @@ var AddressMap = class {
    * @returns
    */
   has(address) {
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = viem.getAddress(address);
     return this.#map.has(key);
   }
   /**
@@ -19211,10 +19199,7 @@ var AddressMap = class {
    * @returns
    */
   get(address) {
-    const key = address.toLowerCase();
-    if (!viem.isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = viem.getAddress(address);
     return this.#map.get(key);
   }
   /**
@@ -19229,6 +19214,9 @@ var AddressMap = class {
     }
     return v;
   }
+  clear() {
+    this.#map.clear();
+  }
   entries() {
     return Array.from(this.#map.entries());
   }
@@ -21346,13 +21334,14 @@ var PriceFeedRegister = class extends SDKConstruct {
     }
     return result;
   }
-  get(address) {
-    return this.#feeds.get(address);
-  }
   mustGet(address) {
     return this.#feeds.mustGet(address);
   }
-  create(data) {
+  getOrCreate(data) {
+    const existing = this.#feeds.get(data.baseParams.addr);
+    if (existing) {
+      return existing;
+    }
     const feed = this.#create(data);
     this.#feeds.upsert(data.baseParams.addr, feed);
     return feed;
@@ -21425,11 +21414,11 @@ var PriceOracleContract = class extends BaseContract {
   /**
    * Mapping Token => [PriceFeed Address, stalenessPeriod]
    */
-  mainPriceFeeds = {};
+  mainPriceFeeds = new AddressMap();
   /**
    * Mapping Token => [PriceFeed Address, stalenessPeriod]
    */
-  reservePriceFeeds = {};
+  reservePriceFeeds = new AddressMap();
   /**
    * Mapping Token => Price in underlying
    */
@@ -21438,7 +21427,7 @@ var PriceOracleContract = class extends BaseContract {
    * Mapping Token => Price in underlying
    */
   reservePrices = new AddressMap();
-  #priceFeedTree;
+  #priceFeedTree = [];
   constructor(sdk, data, underlying) {
     super(sdk, {
       ...data.baseParams,
@@ -21447,32 +21436,7 @@ var PriceOracleContract = class extends BaseContract {
     });
     this.underlying = underlying;
     const { priceFeedMapping, priceFeedStructure } = data;
-    this.#priceFeedTree = priceFeedStructure;
-    for (const node of priceFeedStructure) {
-      sdk.priceFeeds.create(node);
-    }
-    priceFeedMapping.forEach((node) => {
-      const { token, priceFeed, reserve, stalenessPeriod } = node;
-      const ref = new PriceFeedRef(sdk, priceFeed, stalenessPeriod);
-      const price = this.#priceFeedTree.find(
-        (n) => n.baseParams.addr === priceFeed
-      )?.answer?.price;
-      if (reserve) {
-        this.reservePriceFeeds[token] = ref;
-        if (price) {
-          this.reservePrices.upsert(token, price);
-        }
-      } else {
-        this.mainPriceFeeds[token] = ref;
-        if (price) {
-          this.mainPrices.upsert(token, price);
-        }
-      }
-      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
-    });
-    this.logger?.debug(
-      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
-    );
+    this.#loadState(priceFeedMapping, priceFeedStructure);
   }
   processLog(log) {
     switch (log.eventName) {
@@ -21496,8 +21460,8 @@ var PriceOracleContract = class extends BaseContract {
     const main = opts?.main ?? true;
     const reserve = opts?.reserve ?? true;
     return tokens.flatMap((t) => [
-      main ? this.mainPriceFeeds[t]?.priceFeed : void 0,
-      reserve ? this.reservePriceFeeds[t]?.priceFeed : void 0
+      main ? this.mainPriceFeeds.get(t)?.priceFeed : void 0,
+      reserve ? this.reservePriceFeeds.get(t)?.priceFeed : void 0
     ]).filter((f) => !!f);
   }
   /**
@@ -21579,6 +21543,65 @@ var PriceOracleContract = class extends BaseContract {
   async updatePrices() {
     await this.sdk.marketRegister.updatePrices([this.address]);
   }
+  syncStateMulticall() {
+    const args = [this.address];
+    if (this.version === 300) {
+      args.push(
+        Array.from(
+          /* @__PURE__ */ new Set([
+            this.underlying,
+            ...this.mainPriceFeeds.keys(),
+            ...this.reservePriceFeeds.keys()
+          ])
+        )
+      );
+    }
+    return {
+      call: {
+        abi: iPriceFeedCompressorAbi,
+        address: this.sdk.addressProvider.getLatestVersion(
+          AP_PRICE_FEED_COMPRESSOR
+        ),
+        functionName: "getPriceFeeds",
+        args
+      },
+      onResult: ([entries, tree]) => {
+        this.#loadState(entries, tree);
+      }
+    };
+  }
+  #loadState(entries, tree) {
+    this.#priceFeedTree = tree;
+    this.mainPriceFeeds.clear();
+    this.reservePriceFeeds.clear();
+    this.mainPrices.clear();
+    this.reservePrices.clear();
+    for (const node of tree) {
+      this.sdk.priceFeeds.getOrCreate(node);
+    }
+    entries.forEach((node) => {
+      const { token, priceFeed, reserve, stalenessPeriod } = node;
+      const ref = new PriceFeedRef(this.sdk, priceFeed, stalenessPeriod);
+      const price = this.#priceFeedTree.find(
+        (n) => n.baseParams.addr === priceFeed
+      )?.answer?.price;
+      if (reserve) {
+        this.reservePriceFeeds.upsert(token, ref);
+        if (price) {
+          this.reservePrices.upsert(token, price);
+        }
+      } else {
+        this.mainPriceFeeds.upsert(token, ref);
+        if (price) {
+          this.mainPrices.upsert(token, price);
+        }
+      }
+      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+    });
+    this.logger?.debug(
+      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
+    );
+  }
   #labelPriceFeed(address, usage, token) {
     this.sdk.provider.addressLabels.set(address, (label) => {
       const symbol = this.sdk.tokensMeta.symbol(token);
@@ -21597,12 +21620,12 @@ var PriceOracleContract = class extends BaseContract {
    * @returns
    */
   #findTokenForPriceFeed(priceFeed) {
-    for (const [token, pf] of Object.entries(this.mainPriceFeeds)) {
+    for (const [token, pf] of this.mainPriceFeeds.entries()) {
       if (pf.address === priceFeed) {
         return [token, false];
       }
     }
-    for (const [token, pf] of Object.entries(this.reservePriceFeeds)) {
+    for (const [token, pf] of this.reservePriceFeeds.entries()) {
       if (pf.address === priceFeed) {
         return [token, true];
       }
@@ -21617,13 +21640,13 @@ var PriceOracleContract = class extends BaseContract {
     return {
       ...super.stateHuman(raw),
       mainPriceFeeds: Object.fromEntries(
-        Object.entries(this.mainPriceFeeds).map(([token, v]) => [
+        this.mainPriceFeeds.entries().map(([token, v]) => [
           this.labelAddress(token),
           v.stateHuman(raw)
         ])
       ),
       reservePriceFeeds: Object.fromEntries(
-        Object.entries(this.reservePriceFeeds).map(([token, v]) => [
+        this.reservePriceFeeds.entries().map(([token, v]) => [
           this.labelAddress(token),
           v.stateHuman(raw)
         ])
@@ -21986,26 +22009,19 @@ var MarketRegister = class extends SDKConstruct {
     this.#logger?.info(`loaded ${markets.length} markets`);
   }
   /**
-   * Loads new prices for given oracles from PriceFeedCompressor, defaults to all oracles
-   * Does not update price feeds, only updates prices
+   * Loads new prices and price feeds for given oracles from PriceFeedCompressor, defaults to all oracles
+   * Supports v300 and v310 oracles
    */
   async updatePrices(oracles) {
-    const oraclez = oracles ?? this.markets.map((m) => m.priceOracle.address);
-    if (!oraclez.length) {
+    const multicalls = this.markets.map((m) => m.priceOracle).filter((o) => !oracles || oracles.includes(o.address)).map((o) => o.syncStateMulticall());
+    if (!multicalls.length) {
       return;
     }
     const { txs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
     const resp = await simulateMulticall(this.provider.publicClient, {
       contracts: [
         ...txs.map(rawTxToMulticallPriceUpdate),
-        ...oraclez.map((o) => ({
-          abi: iPriceFeedCompressorAbi,
-          address: this.sdk.addressProvider.getLatestVersion(
-            AP_PRICE_FEED_COMPRESSOR
-          ),
-          functionName: "getPriceFeeds",
-          args: [o]
-        }))
+        ...multicalls.map((mc) => mc.call)
       ],
       allowFailure: false,
       gas: 550000000n,
@@ -22013,18 +22029,10 @@ var MarketRegister = class extends SDKConstruct {
       // we cannot have price updates and compressor request in different batches
     });
     const oraclesStates = resp.slice(txs.length);
-    for (let i = 0; i < oraclez.length; i++) {
-      const oracleAddr = oraclez[i];
-      const oracle = this.findPriceOracle(oracleAddr);
-      const [entries, tree] = oraclesStates[i];
-      for (const { token, priceFeed, reserve } of entries) {
-        const price = tree.find((n) => n.baseParams.addr === priceFeed)?.answer?.price;
-        if (reserve && price) {
-          oracle.reservePrices.upsert(token, price);
-        } else if (price) {
-          oracle.mainPrices.upsert(token, price);
-        }
-      }
+    for (let i = 0; i < multicalls.length; i++) {
+      const handler = multicalls[i].onResult;
+      const result = oraclesStates[i];
+      handler(result);
     }
   }
   get state() {

package/dist/cjs/sdk/index.d.ts CHANGED Viewed

@@ -22086,6 +22086,7 @@ declare class AddressMap<T> {
      * @returns
      */
     mustGet(address: string): T;
+    clear(): void;
     entries(): Array<[Address, T]>;
     values(): T[];
     keys(): Address[];
@@ -22297,9 +22298,8 @@ declare class PriceFeedRegister extends SDKConstruct implements IHooks<PriceFeed
      * @returns
      */
     generatePriceFeedsUpdateTxs(priceFeeds?: IPriceFeedContract[]): Promise<UpdatePriceFeedsResult>;
-    get(address: Address): IPriceFeedContract | undefined;
     mustGet(address: Address): IPriceFeedContract;
-    create(data: PriceFeedTreeNode): IPriceFeedContract;
+    getOrCreate(data: PriceFeedTreeNode): IPriceFeedContract;
     /**
      * Set redstone historical timestamp
      * @param timestampMs in milliseconds
@@ -22468,11 +22468,11 @@ declare class PriceOracleContract extends BaseContract<abi$c> {
     /**
      * Mapping Token => [PriceFeed Address, stalenessPeriod]
      */
-    readonly mainPriceFeeds: Record<Address, PriceFeedRef>;
+    readonly mainPriceFeeds: AddressMap<PriceFeedRef>;
     /**
      * Mapping Token => [PriceFeed Address, stalenessPeriod]
      */
-    readonly reservePriceFeeds: Record<Address, PriceFeedRef>;
+    readonly reservePriceFeeds: AddressMap<PriceFeedRef>;
     /**
      * Mapping Token => Price in underlying
      */
@@ -22523,6 +22523,315 @@ declare class PriceOracleContract extends BaseContract<abi$c> {
      * Does not update price feeds, only updates prices
      */
     updatePrices(): Promise<void>;
+    syncStateMulticall(): {
+        call: {
+            abi: readonly [{
+                readonly type: "function";
+                readonly inputs: readonly [];
+                readonly name: "contractType";
+                readonly outputs: readonly [{
+                    readonly name: "";
+                    readonly internalType: "bytes32";
+                    readonly type: "bytes32";
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceOracle";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                }, {
+                    readonly name: "tokens";
+                    readonly internalType: "address[]";
+                    readonly type: "address[]";
+                }];
+                readonly name: "getPriceFeeds";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedMap";
+                    readonly internalType: "struct PriceFeedMapEntry[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "token";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "reserve";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "priceFeed";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "stalenessPeriod";
+                        readonly internalType: "uint32";
+                        readonly type: "uint32";
+                    }];
+                }, {
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceOracle";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                }];
+                readonly name: "getPriceFeeds";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedMap";
+                    readonly internalType: "struct PriceFeedMapEntry[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "token";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "reserve";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "priceFeed";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "stalenessPeriod";
+                        readonly internalType: "uint32";
+                        readonly type: "uint32";
+                    }];
+                }, {
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceFeeds";
+                    readonly internalType: "address[]";
+                    readonly type: "address[]";
+                }];
+                readonly name: "loadPriceFeedTree";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [];
+                readonly name: "version";
+                readonly outputs: readonly [{
+                    readonly name: "";
+                    readonly internalType: "uint256";
+                    readonly type: "uint256";
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "event";
+                readonly anonymous: false;
+                readonly inputs: readonly [{
+                    readonly name: "contractType";
+                    readonly internalType: "bytes32";
+                    readonly type: "bytes32";
+                    readonly indexed: true;
+                }, {
+                    readonly name: "serializer";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                    readonly indexed: true;
+                }];
+                readonly name: "SetSerializer";
+            }];
+            address: `0x${string}`;
+            functionName: string;
+            args: any[];
+        };
+        onResult: ([entries, tree]: [PriceFeedMapEntry[], PriceFeedTreeNode[]]) => void;
+    };
     stateHuman(raw?: boolean): PriceOracleV3StateHuman;
 }
@@ -24223,8 +24532,8 @@ declare class MarketRegister extends SDKConstruct {
     loadMarkets(curators: Address[]): Promise<void>;
     syncState(): Promise<void>;
     /**
-     * Loads new prices for given oracles from PriceFeedCompressor, defaults to all oracles
-     * Does not update price feeds, only updates prices
+     * Loads new prices and price feeds for given oracles from PriceFeedCompressor, defaults to all oracles
+     * Supports v300 and v310 oracles
      */
     updatePrices(oracles?: Address[]): Promise<void>;
     get state(): MarketData[];

package/dist/esm/sdk/index.d.mts CHANGED Viewed

@@ -22086,6 +22086,7 @@ declare class AddressMap<T> {
      * @returns
      */
     mustGet(address: string): T;
+    clear(): void;
     entries(): Array<[Address, T]>;
     values(): T[];
     keys(): Address[];
@@ -22297,9 +22298,8 @@ declare class PriceFeedRegister extends SDKConstruct implements IHooks<PriceFeed
      * @returns
      */
     generatePriceFeedsUpdateTxs(priceFeeds?: IPriceFeedContract[]): Promise<UpdatePriceFeedsResult>;
-    get(address: Address): IPriceFeedContract | undefined;
     mustGet(address: Address): IPriceFeedContract;
-    create(data: PriceFeedTreeNode): IPriceFeedContract;
+    getOrCreate(data: PriceFeedTreeNode): IPriceFeedContract;
     /**
      * Set redstone historical timestamp
      * @param timestampMs in milliseconds
@@ -22468,11 +22468,11 @@ declare class PriceOracleContract extends BaseContract<abi$c> {
     /**
      * Mapping Token => [PriceFeed Address, stalenessPeriod]
      */
-    readonly mainPriceFeeds: Record<Address, PriceFeedRef>;
+    readonly mainPriceFeeds: AddressMap<PriceFeedRef>;
     /**
      * Mapping Token => [PriceFeed Address, stalenessPeriod]
      */
-    readonly reservePriceFeeds: Record<Address, PriceFeedRef>;
+    readonly reservePriceFeeds: AddressMap<PriceFeedRef>;
     /**
      * Mapping Token => Price in underlying
      */
@@ -22523,6 +22523,315 @@ declare class PriceOracleContract extends BaseContract<abi$c> {
      * Does not update price feeds, only updates prices
      */
     updatePrices(): Promise<void>;
+    syncStateMulticall(): {
+        call: {
+            abi: readonly [{
+                readonly type: "function";
+                readonly inputs: readonly [];
+                readonly name: "contractType";
+                readonly outputs: readonly [{
+                    readonly name: "";
+                    readonly internalType: "bytes32";
+                    readonly type: "bytes32";
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceOracle";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                }, {
+                    readonly name: "tokens";
+                    readonly internalType: "address[]";
+                    readonly type: "address[]";
+                }];
+                readonly name: "getPriceFeeds";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedMap";
+                    readonly internalType: "struct PriceFeedMapEntry[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "token";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "reserve";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "priceFeed";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "stalenessPeriod";
+                        readonly internalType: "uint32";
+                        readonly type: "uint32";
+                    }];
+                }, {
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceOracle";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                }];
+                readonly name: "getPriceFeeds";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedMap";
+                    readonly internalType: "struct PriceFeedMapEntry[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "token";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "reserve";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "priceFeed";
+                        readonly internalType: "address";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "stalenessPeriod";
+                        readonly internalType: "uint32";
+                        readonly type: "uint32";
+                    }];
+                }, {
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [{
+                    readonly name: "priceFeeds";
+                    readonly internalType: "address[]";
+                    readonly type: "address[]";
+                }];
+                readonly name: "loadPriceFeedTree";
+                readonly outputs: readonly [{
+                    readonly name: "priceFeedTree";
+                    readonly internalType: "struct PriceFeedTreeNode[]";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "baseParams";
+                        readonly internalType: "struct BaseParams";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "addr";
+                            readonly internalType: "address";
+                            readonly type: "address";
+                        }, {
+                            readonly name: "version";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "contractType";
+                            readonly internalType: "bytes32";
+                            readonly type: "bytes32";
+                        }, {
+                            readonly name: "serializedParams";
+                            readonly internalType: "bytes";
+                            readonly type: "bytes";
+                        }];
+                    }, {
+                        readonly name: "decimals";
+                        readonly internalType: "uint8";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "skipCheck";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "updatable";
+                        readonly internalType: "bool";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "underlyingFeeds";
+                        readonly internalType: "address[]";
+                        readonly type: "address[]";
+                    }, {
+                        readonly name: "underlyingStalenessPeriods";
+                        readonly internalType: "uint32[]";
+                        readonly type: "uint32[]";
+                    }, {
+                        readonly name: "answer";
+                        readonly internalType: "struct PriceFeedAnswer";
+                        readonly type: "tuple";
+                        readonly components: readonly [{
+                            readonly name: "price";
+                            readonly internalType: "int256";
+                            readonly type: "int256";
+                        }, {
+                            readonly name: "updatedAt";
+                            readonly internalType: "uint256";
+                            readonly type: "uint256";
+                        }, {
+                            readonly name: "success";
+                            readonly internalType: "bool";
+                            readonly type: "bool";
+                        }];
+                    }];
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "function";
+                readonly inputs: readonly [];
+                readonly name: "version";
+                readonly outputs: readonly [{
+                    readonly name: "";
+                    readonly internalType: "uint256";
+                    readonly type: "uint256";
+                }];
+                readonly stateMutability: "view";
+            }, {
+                readonly type: "event";
+                readonly anonymous: false;
+                readonly inputs: readonly [{
+                    readonly name: "contractType";
+                    readonly internalType: "bytes32";
+                    readonly type: "bytes32";
+                    readonly indexed: true;
+                }, {
+                    readonly name: "serializer";
+                    readonly internalType: "address";
+                    readonly type: "address";
+                    readonly indexed: true;
+                }];
+                readonly name: "SetSerializer";
+            }];
+            address: `0x${string}`;
+            functionName: string;
+            args: any[];
+        };
+        onResult: ([entries, tree]: [PriceFeedMapEntry[], PriceFeedTreeNode[]]) => void;
+    };
     stateHuman(raw?: boolean): PriceOracleV3StateHuman;
 }
@@ -24223,8 +24532,8 @@ declare class MarketRegister extends SDKConstruct {
     loadMarkets(curators: Address[]): Promise<void>;
     syncState(): Promise<void>;
     /**
-     * Loads new prices for given oracles from PriceFeedCompressor, defaults to all oracles
-     * Does not update price feeds, only updates prices
+     * Loads new prices and price feeds for given oracles from PriceFeedCompressor, defaults to all oracles
+     * Supports v300 and v310 oracles
      */
     updatePrices(oracles?: Address[]): Promise<void>;
     get state(): MarketData[];

package/dist/esm/sdk/index.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-import { isAddress, bytesToString, toBytes, prepareEncodeFunctionData, encodeAbiParameters, concatHex, getContract, isHex, decodeFunctionData, encodeFunctionData, decodeAbiParameters, erc4626Abi, http, fallback, defineChain, createPublicClient, getChainContractAddress, getContractError, multicall3Abi, AbiDecodingZeroDataError, RawContractError, decodeFunctionResult, BaseError, parseEventLogs, hexToBytes } from 'viem';
+import { getAddress, bytesToString, toBytes, prepareEncodeFunctionData, encodeAbiParameters, concatHex, getContract, isHex, decodeFunctionData, encodeFunctionData, decodeAbiParameters, erc4626Abi, http, fallback, defineChain, createPublicClient, getChainContractAddress, getContractError, multicall3Abi, AbiDecodingZeroDataError, RawContractError, decodeFunctionResult, BaseError, parseEventLogs, hexToBytes } from 'viem';
 import { formatAbiItem, getAction } from 'viem/utils';
 import { intervalToDuration, formatDuration as formatDuration$1 } from 'date-fns';
 import { DataServiceWrapper } from '@redstone-finance/evm-connector';
@@ -19150,10 +19150,7 @@ var AddressMap = class {
     this.#map = /* @__PURE__ */ new Map();
     if (entries) {
       for (const [address, value] of entries) {
-        const key = address.toLowerCase();
-        if (!isAddress(key)) {
-          throw new Error(`value "${address}" is not an address`);
-        }
+        const key = getAddress(address);
         this.#map.set(key, value);
       }
     }
@@ -19167,10 +19164,7 @@ var AddressMap = class {
     if (this.#frozen) {
       throw new Error(`AddressMap is frozen`);
     }
-    const key = address.toLowerCase();
-    if (!isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = getAddress(address);
     this.#map.set(key, value);
   }
   /**
@@ -19182,10 +19176,7 @@ var AddressMap = class {
     if (this.#frozen) {
       throw new Error(`AddressMap is frozen`);
     }
-    const key = address.toLowerCase();
-    if (!isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = getAddress(address);
     if (this.#map.has(key)) {
       throw new Error(`address ${address} already exists`);
     }
@@ -19197,10 +19188,7 @@ var AddressMap = class {
    * @returns
    */
   has(address) {
-    const key = address.toLowerCase();
-    if (!isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = getAddress(address);
     return this.#map.has(key);
   }
   /**
@@ -19209,10 +19197,7 @@ var AddressMap = class {
    * @returns
    */
   get(address) {
-    const key = address.toLowerCase();
-    if (!isAddress(key)) {
-      throw new Error(`value "${address}" is not an address`);
-    }
+    const key = getAddress(address);
     return this.#map.get(key);
   }
   /**
@@ -19227,6 +19212,9 @@ var AddressMap = class {
     }
     return v;
   }
+  clear() {
+    this.#map.clear();
+  }
   entries() {
     return Array.from(this.#map.entries());
   }
@@ -21344,13 +21332,14 @@ var PriceFeedRegister = class extends SDKConstruct {
     }
     return result;
   }
-  get(address) {
-    return this.#feeds.get(address);
-  }
   mustGet(address) {
     return this.#feeds.mustGet(address);
   }
-  create(data) {
+  getOrCreate(data) {
+    const existing = this.#feeds.get(data.baseParams.addr);
+    if (existing) {
+      return existing;
+    }
     const feed = this.#create(data);
     this.#feeds.upsert(data.baseParams.addr, feed);
     return feed;
@@ -21423,11 +21412,11 @@ var PriceOracleContract = class extends BaseContract {
   /**
    * Mapping Token => [PriceFeed Address, stalenessPeriod]
    */
-  mainPriceFeeds = {};
+  mainPriceFeeds = new AddressMap();
   /**
    * Mapping Token => [PriceFeed Address, stalenessPeriod]
    */
-  reservePriceFeeds = {};
+  reservePriceFeeds = new AddressMap();
   /**
    * Mapping Token => Price in underlying
    */
@@ -21436,7 +21425,7 @@ var PriceOracleContract = class extends BaseContract {
    * Mapping Token => Price in underlying
    */
   reservePrices = new AddressMap();
-  #priceFeedTree;
+  #priceFeedTree = [];
   constructor(sdk, data, underlying) {
     super(sdk, {
       ...data.baseParams,
@@ -21445,32 +21434,7 @@ var PriceOracleContract = class extends BaseContract {
     });
     this.underlying = underlying;
     const { priceFeedMapping, priceFeedStructure } = data;
-    this.#priceFeedTree = priceFeedStructure;
-    for (const node of priceFeedStructure) {
-      sdk.priceFeeds.create(node);
-    }
-    priceFeedMapping.forEach((node) => {
-      const { token, priceFeed, reserve, stalenessPeriod } = node;
-      const ref = new PriceFeedRef(sdk, priceFeed, stalenessPeriod);
-      const price = this.#priceFeedTree.find(
-        (n) => n.baseParams.addr === priceFeed
-      )?.answer?.price;
-      if (reserve) {
-        this.reservePriceFeeds[token] = ref;
-        if (price) {
-          this.reservePrices.upsert(token, price);
-        }
-      } else {
-        this.mainPriceFeeds[token] = ref;
-        if (price) {
-          this.mainPrices.upsert(token, price);
-        }
-      }
-      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
-    });
-    this.logger?.debug(
-      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
-    );
+    this.#loadState(priceFeedMapping, priceFeedStructure);
   }
   processLog(log) {
     switch (log.eventName) {
@@ -21494,8 +21458,8 @@ var PriceOracleContract = class extends BaseContract {
     const main = opts?.main ?? true;
     const reserve = opts?.reserve ?? true;
     return tokens.flatMap((t) => [
-      main ? this.mainPriceFeeds[t]?.priceFeed : void 0,
-      reserve ? this.reservePriceFeeds[t]?.priceFeed : void 0
+      main ? this.mainPriceFeeds.get(t)?.priceFeed : void 0,
+      reserve ? this.reservePriceFeeds.get(t)?.priceFeed : void 0
     ]).filter((f) => !!f);
   }
   /**
@@ -21577,6 +21541,65 @@ var PriceOracleContract = class extends BaseContract {
   async updatePrices() {
     await this.sdk.marketRegister.updatePrices([this.address]);
   }
+  syncStateMulticall() {
+    const args = [this.address];
+    if (this.version === 300) {
+      args.push(
+        Array.from(
+          /* @__PURE__ */ new Set([
+            this.underlying,
+            ...this.mainPriceFeeds.keys(),
+            ...this.reservePriceFeeds.keys()
+          ])
+        )
+      );
+    }
+    return {
+      call: {
+        abi: iPriceFeedCompressorAbi,
+        address: this.sdk.addressProvider.getLatestVersion(
+          AP_PRICE_FEED_COMPRESSOR
+        ),
+        functionName: "getPriceFeeds",
+        args
+      },
+      onResult: ([entries, tree]) => {
+        this.#loadState(entries, tree);
+      }
+    };
+  }
+  #loadState(entries, tree) {
+    this.#priceFeedTree = tree;
+    this.mainPriceFeeds.clear();
+    this.reservePriceFeeds.clear();
+    this.mainPrices.clear();
+    this.reservePrices.clear();
+    for (const node of tree) {
+      this.sdk.priceFeeds.getOrCreate(node);
+    }
+    entries.forEach((node) => {
+      const { token, priceFeed, reserve, stalenessPeriod } = node;
+      const ref = new PriceFeedRef(this.sdk, priceFeed, stalenessPeriod);
+      const price = this.#priceFeedTree.find(
+        (n) => n.baseParams.addr === priceFeed
+      )?.answer?.price;
+      if (reserve) {
+        this.reservePriceFeeds.upsert(token, ref);
+        if (price) {
+          this.reservePrices.upsert(token, price);
+        }
+      } else {
+        this.mainPriceFeeds.upsert(token, ref);
+        if (price) {
+          this.mainPrices.upsert(token, price);
+        }
+      }
+      this.#labelPriceFeed(priceFeed, reserve ? "Reserve" : "Main", token);
+    });
+    this.logger?.debug(
+      `Got ${Object.keys(this.mainPriceFeeds).length} main and ${Object.keys(this.reservePriceFeeds).length} reserve price feeds`
+    );
+  }
   #labelPriceFeed(address, usage, token) {
     this.sdk.provider.addressLabels.set(address, (label) => {
       const symbol = this.sdk.tokensMeta.symbol(token);
@@ -21595,12 +21618,12 @@ var PriceOracleContract = class extends BaseContract {
    * @returns
    */
   #findTokenForPriceFeed(priceFeed) {
-    for (const [token, pf] of Object.entries(this.mainPriceFeeds)) {
+    for (const [token, pf] of this.mainPriceFeeds.entries()) {
       if (pf.address === priceFeed) {
         return [token, false];
       }
     }
-    for (const [token, pf] of Object.entries(this.reservePriceFeeds)) {
+    for (const [token, pf] of this.reservePriceFeeds.entries()) {
       if (pf.address === priceFeed) {
         return [token, true];
       }
@@ -21615,13 +21638,13 @@ var PriceOracleContract = class extends BaseContract {
     return {
       ...super.stateHuman(raw),
       mainPriceFeeds: Object.fromEntries(
-        Object.entries(this.mainPriceFeeds).map(([token, v]) => [
+        this.mainPriceFeeds.entries().map(([token, v]) => [
           this.labelAddress(token),
           v.stateHuman(raw)
         ])
       ),
       reservePriceFeeds: Object.fromEntries(
-        Object.entries(this.reservePriceFeeds).map(([token, v]) => [
+        this.reservePriceFeeds.entries().map(([token, v]) => [
           this.labelAddress(token),
           v.stateHuman(raw)
         ])
@@ -21984,26 +22007,19 @@ var MarketRegister = class extends SDKConstruct {
     this.#logger?.info(`loaded ${markets.length} markets`);
   }
   /**
-   * Loads new prices for given oracles from PriceFeedCompressor, defaults to all oracles
-   * Does not update price feeds, only updates prices
+   * Loads new prices and price feeds for given oracles from PriceFeedCompressor, defaults to all oracles
+   * Supports v300 and v310 oracles
    */
   async updatePrices(oracles) {
-    const oraclez = oracles ?? this.markets.map((m) => m.priceOracle.address);
-    if (!oraclez.length) {
+    const multicalls = this.markets.map((m) => m.priceOracle).filter((o) => !oracles || oracles.includes(o.address)).map((o) => o.syncStateMulticall());
+    if (!multicalls.length) {
       return;
     }
     const { txs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
     const resp = await simulateMulticall(this.provider.publicClient, {
       contracts: [
         ...txs.map(rawTxToMulticallPriceUpdate),
-        ...oraclez.map((o) => ({
-          abi: iPriceFeedCompressorAbi,
-          address: this.sdk.addressProvider.getLatestVersion(
-            AP_PRICE_FEED_COMPRESSOR
-          ),
-          functionName: "getPriceFeeds",
-          args: [o]
-        }))
+        ...multicalls.map((mc) => mc.call)
       ],
       allowFailure: false,
       gas: 550000000n,
@@ -22011,18 +22027,10 @@ var MarketRegister = class extends SDKConstruct {
       // we cannot have price updates and compressor request in different batches
     });
     const oraclesStates = resp.slice(txs.length);
-    for (let i = 0; i < oraclez.length; i++) {
-      const oracleAddr = oraclez[i];
-      const oracle = this.findPriceOracle(oracleAddr);
-      const [entries, tree] = oraclesStates[i];
-      for (const { token, priceFeed, reserve } of entries) {
-        const price = tree.find((n) => n.baseParams.addr === priceFeed)?.answer?.price;
-        if (reserve && price) {
-          oracle.reservePrices.upsert(token, price);
-        } else if (price) {
-          oracle.mainPrices.upsert(token, price);
-        }
-      }
+    for (let i = 0; i < multicalls.length; i++) {
+      const handler = multicalls[i].onResult;
+      const result = oraclesStates[i];
+      handler(result);
     }
   }
   get state() {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "3.0.0-vfour.65",
+  "version": "3.0.0-vfour.67",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.cjs",