fix up the bridge data class (#63)

* fix up the bridge data class

* update yarn.lock

* increment version

Author: Joe Andrews

package.json

@@ -18,7 +18,6 @@
   },
   "dependencies": {
     "@ethersproject/providers": "^5.6.5",
-    "axios": "^0.26.1",
     "detect-node": "^2.1.0",
     "sha3": "^2.1.4"
   },
@@ -30,7 +29,7 @@
     "rootDir": "./src"
   },
   "name": "@aztec/bridge-clients",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "This repo contains the solidity files and typescript helper class for all of the Aztec Connect Bridge Contracts",
   "repository": "[email protected]:AztecProtocol/aztec-connect-bridges.git",
   "license": "MIT",
@@ -44,9 +43,11 @@
     "@typechain/hardhat": "^4.0.0",
     "@types/detect-node": "^2.0.0",
     "@types/jest": "^27.4.0",
+    "@types/node-fetch": "^2.6.1",
     "ethers": "^5.5.4",
     "hardhat": "^2.6.8",
     "jest": "^27.5.0",
+    "node-fetch": "2.6.7",
     "ts-jest": "^27.1.3",
     "ts-node": "^10.4.0",
     "typechain": "^7.0.1",

src/client/bridge-data.ts

@@ -34,18 +34,18 @@ export interface AuxDataConfig {
   solidityType: SolidityType;
 }
 
-export interface BridgeData {
+export interface BridgeDataFieldGetters {
   /*
   @dev This function should be implemented for stateful bridges. It's purpose is to tell the developer using the bridge the value of a given interaction.
   @dev The value should be returned as an array of AssetValue's
   */
-  getInteractionPresentValue(interactionNonce: bigint): Promise<AssetValue[]>;
+  getInteractionPresentValue?(interactionNonce: bigint): Promise<AssetValue[]>;
 
   /*
   @dev This function should be implemented for all bridges that use auxData that require onchain data. It's purpose is to tell the developer using the bridge
   @dev the set of possible auxData's that they can use for a given set of inputOutputAssets.
   */
-  getAuxData(
+  getAuxData?(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
@@ -70,44 +70,50 @@ export interface BridgeData {
     auxData: bigint,
     inputValue: bigint,
   ): Promise<bigint[]>;
-}
 
-export interface AsyncBridgeData extends BridgeData {
   /*
   @dev This function should be implemented for async bridges. It should return the date at which the bridge is expected to be finalised.
   @dev For limit orders this should be the expiration.
   */
-  getExpiration(interactionNonce: bigint): Promise<bigint>;
+  getExpiration?(interactionNonce: bigint): Promise<bigint>;
 
-  hasFinalised(interactionNonce: bigint): Promise<Boolean>;
-}
+  hasFinalised?(interactionNonce: bigint): Promise<Boolean>;
 
-export interface YieldBridgeData extends BridgeData {
   /*
   @dev This function should be implemented for all bridges are stateful. It should return the expected value 1 year from now of outputAssetA and outputAssetB
   @dev given inputValue of inputAssetA and inputAssetB
   */
 
-  getExpectedYearlyOuput(
+  getExpectedYeild?(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
     outputAssetB: AztecAsset,
     auxData: bigint,
     inputValue: bigint,
-  ): Promise<bigint[]>;
+  ): Promise<number[]>;
 
   /*
-  @dev This function should be implemented for all bridges. It should return the Layer liquidity this bridge call will be interacting with
+  @dev This function should be implemented for all bridges dealing with L1 liqudity pools. It should return the Layer liquidity this bridge call will be interacting with
   @dev e.g the liquidity of the underlying yield pool or AMM for a given pair
   */
-  getMarketSize(
+  getMarketSize?(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
     outputAssetB: AztecAsset,
     auxData: bigint,
   ): Promise<AssetValue[]>;
-}
 
-export interface AsyncYieldBridgeData extends YieldBridgeData, AsyncBridgeData {}
+  /*
+  @dev This function should be implemented for all async yield bridges.
+  @dev It should return the yield for a given interaction
+  */
+  getCurrentYield?(interactionNonce: bigint): Promise<number[]>;
+
+  /*
+  @dev This function should be implemented for swap / LP bridges.
+  @dev It should return a packed aux data taking into account a dynamic price and fee
+  */
+  lPAuxData?(data: bigint[]): Promise<bigint[]>;
+}

src/client/element/element-bridge-data.test.ts

@@ -251,7 +251,7 @@ describe('element bridge data', () => {
       balancerContract as any,
       rollupContract as any,
     );
-    const output = await elementBridgeData.getExpectedYearlyOuput(
+    const output = await elementBridgeData.getExpectedYield(
       {
         assetType: AztecAssetType.ERC20,
         erc20Address: 'test',
@@ -280,7 +280,7 @@ describe('element bridge data', () => {
     const scaledOut = (BigInt(interest) * elementBridgeData.scalingFactor) / timeToExpiration;
     const yearlyOut = (scaledOut * BigInt(YEAR)) / elementBridgeData.scalingFactor;
 
-    expect(output[0]).toBe(yearlyOut + BigInt(inputValue));
+    expect(output[0]).toBe(Number((BigInt(inputValue) / (yearlyOut + BigInt(inputValue))) * 100n));
   });
 
   it('should return the correct market size for a given tranche', async () => {

src/client/element/element-bridge-data.ts

@@ -1,6 +1,6 @@
 import { BridgeId } from '../aztec/bridge_id';
 import { AddressZero } from '@ethersproject/constants';
-import { AssetValue, AsyncYieldBridgeData, AuxDataConfig, AztecAsset, SolidityType } from '../bridge-data';
+import { AssetValue, BridgeDataFieldGetters, AuxDataConfig, AztecAsset, SolidityType } from '../bridge-data';
 import {
   ElementBridge,
   IVault,
@@ -68,7 +68,7 @@ const decodeEvent = async (event: AsyncDefiBridgeProcessedEvent) => {
   return newEventBlock;
 };
 
-export class ElementBridgeData implements AsyncYieldBridgeData {
+export class ElementBridgeData implements BridgeDataFieldGetters {
   public scalingFactor = BigInt(1n * 10n ** 18n);
   private interactionBlockNumbers: Array<EventBlock> = [];
 
@@ -211,13 +211,44 @@ export class ElementBridgeData implements AsyncYieldBridgeData {
     ];
   }
 
+  async getCurrentYield(interactionNonce: bigint): Promise<number[]> {
+    const interaction = await this.elementBridgeContract.interactions(interactionNonce);
+    if (interaction === undefined) {
+      return [];
+    }
+    const exitTimestamp = interaction.expiry;
+    const endValue = interaction.quantityPT;
+
+    // we get the present value of the interaction
+    const defiEvent = await this.findDefiEventForNonce(interactionNonce);
+    if (defiEvent === undefined) {
+      return [];
+    }
+
+    const latestBlock = await this.getCurrentBlock();
+
+    const now = latestBlock.timestamp;
+    const totalInterest = endValue.toBigInt() - defiEvent.totalInputValue;
+    const elapsedTime = BigInt(now - defiEvent.timestamp);
+    const totalTime = exitTimestamp.toBigInt() - BigInt(defiEvent.timestamp);
+    const timeRatio = divide(elapsedTime, totalTime, this.scalingFactor);
+    const accruedInterst = (totalInterest * timeRatio) / this.scalingFactor;
+
+    const currentYield = (defiEvent.totalInputValue / (defiEvent.totalInputValue + accruedInterst)) * 100n;
+    return [Number(currentYield)];
+  }
+
   async getAuxData(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
     outputAssetB: AztecAsset,
   ): Promise<bigint[]> {
-    return (await this.elementBridgeContract.getAssetExpiries(inputAssetA.erc20Address)).map(a => a.toBigInt());
+    const assetExpiries = await this.elementBridgeContract.getAssetExpiries(inputAssetA.erc20Address);
+    if (assetExpiries && assetExpiries.length) {
+      return assetExpiries.map(a => a.toBigInt());
+    }
+    return [];
   }
 
   public auxDataConfig: AuxDataConfig[] = [
@@ -241,14 +272,14 @@ export class ElementBridgeData implements AsyncYieldBridgeData {
     return [BigInt(0), BigInt(0), BigInt(1)];
   }
 
-  async getExpectedYearlyOuput(
+  async getExpectedYield(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
     outputAssetB: AztecAsset,
     auxData: bigint,
     precision: bigint,
-  ): Promise<bigint[]> {
+  ): Promise<number[]> {
     const assetExpiryHash = await this.elementBridgeContract.hashAssetAndExpiry(inputAssetA.erc20Address, auxData);
     const pool = await this.elementBridgeContract.pools(assetExpiryHash);
     const poolId = pool.poolId;
@@ -287,7 +318,7 @@ export class ElementBridgeData implements AsyncYieldBridgeData {
     const scaledOutput = divide(interest, timeToExpiration, this.scalingFactor);
     const yearlyOutput = (scaledOutput * YEAR) / this.scalingFactor;
 
-    return [yearlyOutput + precision, BigInt(0)];
+    return [Number((precision * this.scalingFactor) / (yearlyOutput + precision) / this.scalingFactor / 10000n) / 100];
   }
 
   async getMarketSize(

src/client/example/example-bridge-data.ts

@@ -1,6 +1,6 @@
-import { AssetValue, AuxDataConfig, AztecAsset, BridgeData, SolidityType } from '../bridge-data';
+import { AssetValue, AuxDataConfig, AztecAsset, BridgeDataFieldGetters, SolidityType } from '../bridge-data';
 
-export class ExampleBridgeData implements BridgeData {
+export class ExampleBridgeData implements BridgeDataFieldGetters {
   constructor() {}
 
   // @dev This function should be implemented for stateful bridges. It should return an array of AssetValue's
@@ -45,17 +45,6 @@ export class ExampleBridgeData implements BridgeData {
     return [100n, 0n];
   }
 
-  async getExpectedYearlyOuput(
-    inputAssetA: AztecAsset,
-    inputAssetB: AztecAsset,
-    outputAssetA: AztecAsset,
-    outputAssetB: AztecAsset,
-    auxData: bigint,
-    precision: bigint,
-  ): Promise<bigint[]> {
-    return [100n, 0n];
-  }
-
   async getMarketSize(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,

src/client/lido/lido-bridge-data.test.ts

@@ -131,7 +131,7 @@ describe('lido bridge data', () => {
 
   it('should correctly return the expectedYearlyOutput', async () => {
     const depositAmount = BigInt(1 * 10e18);
-    const expectedOutput = 10432001397269423610n;
+    const expectedOutput = 4.32;
 
     wstethContract = {
       ...wstethContract,
@@ -160,7 +160,7 @@ describe('lido bridge data', () => {
 
     lidoBridgeData = createLidoBridgeData(wstethContract as any, curvePoolContract as any, lidoOracleContract as any);
 
-    const output = await lidoBridgeData.getExpectedYearlyOuput(
+    const output = await lidoBridgeData.getExpectedYield(
       wstETHAsset,
       emptyAsset,
       ethAsset,

src/client/lido/lido-bridge-data.ts

@@ -1,4 +1,4 @@
-import { AssetValue, AuxDataConfig, AztecAsset, SolidityType, AztecAssetType, YieldBridgeData } from '../bridge-data';
+import { AssetValue, AuxDataConfig, AztecAsset, SolidityType, AztecAssetType, BridgeDataFieldGetters } from '../bridge-data';
 
 import {
   IWstETH,
@@ -11,7 +11,7 @@ import {
 import { createWeb3Provider, EthereumProvider } from '../aztec/provider';
 import { EthAddress } from '../aztec/eth_address';
 
-export class LidoBridgeData implements YieldBridgeData {
+export class LidoBridgeData implements BridgeDataFieldGetters {
   public scalingFactor: bigint = 1n * 10n ** 18n;
 
   private constructor(
@@ -84,14 +84,14 @@ export class LidoBridgeData implements YieldBridgeData {
     }
     return [0n];
   }
-  async getExpectedYearlyOuput(
+  async getExpectedYield(
     inputAssetA: AztecAsset,
     inputAssetB: AztecAsset,
     outputAssetA: AztecAsset,
     outputAssetB: AztecAsset,
     auxData: bigint,
     precision: bigint,
-  ): Promise<bigint[]> {
+  ): Promise<Number[]> {
     const YEAR = 60n * 60n * 24n * 365n;
     if (outputAssetA.assetType === AztecAssetType.ETH) {
       const { postTotalPooledEther, preTotalPooledEther, timeElapsed } =
@@ -100,13 +100,10 @@ export class LidoBridgeData implements YieldBridgeData {
       const scaledAPR =
         ((postTotalPooledEther.toBigInt() - preTotalPooledEther.toBigInt()) * YEAR * this.scalingFactor) /
         (preTotalPooledEther.toBigInt() * timeElapsed.toBigInt());
-      const stETHBalance = await this.wstETHContract.getStETHByWstETH(precision);
-      const ETHBalance = (await this.curvePoolContract.get_dy(1, 0, stETHBalance)).toBigInt();
-      const expectedYearlyOutputETH = ETHBalance + (ETHBalance * scaledAPR) / this.scalingFactor;
 
-      return [expectedYearlyOutputETH];
+      return [Number(scaledAPR / (this.scalingFactor / 10000n)) / 100];
     }
-    return [0n];
+    return [0];
   }
 
   async getMarketSize(