feat: umbrella

packages/contract-helpers/src/commons/types.ts

@@ -1,4 +1,5 @@
-import { BigNumber, BytesLike, PopulatedTransaction } from 'ethers';
+import { BigNumber } from '@ethersproject/bignumber';
+import { BytesLike, PopulatedTransaction } from 'ethers';
 import {
   LPBorrowParamsType,
   LPRepayParamsType,
@@ -158,6 +159,26 @@ export enum ProtocolAction {
   batchMetaDelegate = 'batchMetaDelegate',
   updateRepresentatives = 'updateRepresentatives',
   migrateABPT = 'migrateABPT',
+  umbrellaStake = 'umbrellaStake',
+  umbrellaStakeWithPermit = 'umbrellaStakeWithPermit',
+  umbrellaStakeWithATokens = 'umbrellaStakeWithATokens',
+  umbrellaStakeWithATokensWithPermit = 'umbrellaStakeWithATokensWithPermit',
+  umbrellaRedeem = 'umbrellaRedeem',
+  umbrellaRedeemATokens = 'umbrellaRedeemATokens',
+  umbrellaStakeTokenCooldown = 'umbrellaStakeTokenCooldown',
+  umbrellaStakeTokenDeposit = 'umbrellaStakeTokenDeposit',
+  umbrellaStakeTokenDepositWithPermit = 'umbrellaStakeTokenDepositWithPermit',
+  umbrellaStakeTokenRedeem = 'umbrellaStakeTokenRedeem',
+  umbrellaClaimAllRewards = 'umbrellaClaimAllRewards',
+  umbrellaClaimSelectedRewards = 'umbrellaClaimSelectedRewards',
+  umbrellaStakeGatewayStake = 'umbrellaStakeGatewayStake',
+  umbrellaStakeGatewayStakeWithPermit = 'umbrellaStakeGatewayStakeWithPermit',
+  umbrellaStakeGatewayStakeATokens = 'umbrellaStakeGatewayStakeATokens',
+  umbrellaStakeGatewayStakeATokensWithPermit = 'umbrellaStakeGatewayStakeATokensWithPermit',
+  umbrellaStakeGatewayStakeNativeTokens = 'umbrellaStakeGatewayStakeNativeTokens',
+  umbrellaStakeGatewayRedeem = 'umbrellaStakeGatewayRedeem',
+  umbrellaStakeGatewayRedeemATokens = 'umbrellaStakeGatewayRedeemATokens',
+  umbrellaStakeGatewayRedeemNativeTokens = 'umbrellaStakeGatewayRedeemNativeTokens',
 }
 
 export enum GovernanceVote {
@@ -406,3 +427,10 @@ export type RepayWithATokensTxBuilder = {
     rateMode,
   }: Omit<LPRepayWithATokensType, 'user'>) => Promise<string>;
 };
+
+export type DefinedPopulatedTransaction = PopulatedTransaction & {
+  data: string;
+  from: string;
+  to: string;
+  gasLimit: BigNumber;
+};

packages/contract-helpers/src/commons/utils.test.ts

@@ -1,4 +1,5 @@
-import { BigNumber } from 'ethers';
+import { BigNumber, Wallet } from 'ethers';
+import { isAddress } from 'ethers/lib/utils';
 import { transactionType } from './types';
 import {
   API_ETH_MOCK_ADDRESS,
@@ -9,6 +10,8 @@ import {
   getTxValue,
   augustusToAmountOffsetFromCalldata,
   convertPopulatedTx,
+  makePair,
+  generateEIP712PermitMock,
 } from './utils';
 
 describe('Utils', () => {
@@ -130,4 +133,35 @@ describe('Utils', () => {
       expect(convertedTx.value).toEqual(BigNumber.from('0'));
     });
   });
+
+  describe('makePair', () => {
+    it('Generates a valid pair', () => {
+      const { address, privateKey } = makePair('test_id');
+      expect(isAddress(address)).toBeTruthy();
+      expect(privateKey).toHaveLength(66);
+      const wallet = new Wallet(privateKey);
+      expect(wallet.address).toEqual(address);
+    });
+    it('Generate always the same pair with same id', () => {
+      const { address: address1, privateKey: privateKey1 } =
+        makePair('test_id');
+      const { address: address2, privateKey: privateKey2 } =
+        makePair('test_id');
+      expect(address1).toEqual(address2);
+      expect(privateKey1).toEqual(privateKey2);
+    });
+  });
+
+  describe('generateEIP712PermitMock', () => {
+    it('Generates valid EIP712 Permit values', () => {
+      const { value } = generateEIP712PermitMock('0x0', '0x1', '100', '1');
+      expect(value).toEqual({
+        owner: '0x0',
+        spender: '0x1',
+        value: '100',
+        nonce: '0',
+        deadline: '1',
+      });
+    });
+  });
 });

packages/contract-helpers/src/commons/utils.ts

@@ -1,5 +1,5 @@
 import { BigNumber as BigNumberJs } from 'bignumber.js';
-import { BigNumber, constants, PopulatedTransaction } from 'ethers';
+import { BigNumber, constants, PopulatedTransaction, utils } from 'ethers';
 import {
   GasRecommendationType,
   ProtocolAction,
@@ -150,6 +150,86 @@ export const gasLimitRecommendations: GasRecommendationType = {
     limit: '750000',
     recommended: '750000',
   },
+  [ProtocolAction.umbrellaStake]: {
+    limit: '400000',
+    recommended: '400000',
+  },
+  [ProtocolAction.umbrellaStakeWithPermit]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeWithATokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeWithATokensWithPermit]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaRedeem]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaRedeemATokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeTokenCooldown]: {
+    limit: '60000',
+    recommended: '60000',
+  },
+  [ProtocolAction.umbrellaStakeTokenDeposit]: {
+    limit: '200000',
+    recommended: '200000',
+  },
+  [ProtocolAction.umbrellaStakeTokenDepositWithPermit]: {
+    limit: '300000',
+    recommended: '300000',
+  },
+  [ProtocolAction.umbrellaStakeTokenRedeem]: {
+    limit: '200000',
+    recommended: '200000',
+  },
+  [ProtocolAction.umbrellaClaimAllRewards]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaClaimSelectedRewards]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayStake]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayStakeWithPermit]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayStakeATokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayStakeATokensWithPermit]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayStakeNativeTokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayRedeem]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayRedeemATokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
+  [ProtocolAction.umbrellaStakeGatewayRedeemNativeTokens]: {
+    limit: '310000',
+    recommended: '310000',
+  },
 };
 
 export const mintAmountsPerToken: Record<string, string> = {
@@ -232,3 +312,48 @@ export const convertPopulatedTx = (
     value: tx.value ? BigNumber.from(tx.value) : BigNumber.from('0'),
   };
 };
+
+export const makePair = (id: string) => {
+  const privateKey = utils.id(id);
+  const address = utils.computeAddress(privateKey);
+  return { privateKey, address };
+};
+
+export const DEFAULT_MOCK_VERIFYING_CONTRACT =
+  '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC';
+
+export const generateEIP712PermitMock = (
+  owner: string,
+  spender: string,
+  amount: string,
+  deadline: string,
+) => {
+  const domain = {
+    name: 'Mocked token',
+    version: '1',
+    chainId: 1,
+    verifyingContract: DEFAULT_MOCK_VERIFYING_CONTRACT,
+  };
+  const types = {
+    Permit: [
+      { name: 'owner', type: 'address' },
+      { name: 'spender', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'nonce', type: 'uint256' },
+      { name: 'deadline', type: 'uint256' },
+    ],
+  };
+  const value = {
+    owner,
+    spender,
+    value: amount,
+    nonce: '0',
+    deadline,
+  };
+
+  return { domain, types, value };
+};
+
+export function expectToBeDefined<T>(value: T | undefined): asserts value is T {
+  expect(value).toBeDefined();
+}

packages/contract-helpers/src/index.ts

@@ -41,6 +41,7 @@ export * from './governance-v3/aave-token-v3';
 export * from './governance-v3/payloads-data-helper';
 export * from './governance-v3/delegate-helper';
 export * from './abpt-migration';
+export * from './umbrella';
 
 // commons
 export * from './commons/types';

packages/contract-helpers/src/umbrella/RewardsDistributor.test.ts

@@ -0,0 +1,92 @@
+import { ProtocolAction } from '../commons/types';
+import {
+  expectToBeDefined,
+  gasLimitRecommendations,
+  makePair,
+} from '../commons/utils';
+import { IRewardsDistributor__factory } from './typechain/IRewardsDistributor__factory';
+import { RewardsDistributorService } from './';
+
+describe('Umbrella Rewards distributor', () => {
+  const { address: STAKE_TOKEN } = makePair('STAKE_TOKEN');
+  const { address: STAKE_TOKEN_2 } = makePair('STAKE_TOKEN_2');
+  const { address: ALICE } = makePair('ALICE');
+
+  const REWARD_1 = makePair('REWARD_1').address;
+  const REWARD_2 = makePair('REWARD_2').address;
+
+  const stakeTokenService = new RewardsDistributorService(STAKE_TOKEN);
+  const stakeTokenInterface = IRewardsDistributor__factory.createInterface();
+  describe('claimAllAvailableRewards', () => {
+    it('should properly create the transaction', () => {
+      const tx = stakeTokenService.claimAllAvailableRewards({
+        stakeTokens: [STAKE_TOKEN, STAKE_TOKEN_2],
+        sender: ALICE,
+      });
+      expect(tx.from).toEqual(ALICE);
+      expect(tx.to).toEqual(STAKE_TOKEN);
+      expectToBeDefined(tx.gasLimit);
+      expectToBeDefined(tx.data);
+      expect(tx.gasLimit.toString()).toEqual(
+        gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards]
+          .recommended,
+      );
+      const decoded = stakeTokenInterface.decodeFunctionData(
+        'claimAllRewards(address[],address)',
+        tx.data,
+      );
+      expect(decoded).toHaveLength(2);
+      expect(decoded[0]).toEqual([STAKE_TOKEN, STAKE_TOKEN_2]);
+      expect(decoded[1]).toEqual(ALICE);
+    });
+  });
+  describe('claimAllRewards', () => {
+    it('should properly create the transaction', () => {
+      const tx = stakeTokenService.claimAllRewards({
+        stakeToken: STAKE_TOKEN,
+        sender: ALICE,
+      });
+      expect(tx.from).toEqual(ALICE);
+      expect(tx.to).toEqual(STAKE_TOKEN);
+      expectToBeDefined(tx.gasLimit);
+      expectToBeDefined(tx.data);
+      expect(tx.gasLimit.toString()).toEqual(
+        gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards]
+          .recommended,
+      );
+      const decoded = stakeTokenInterface.decodeFunctionData(
+        'claimAllRewards(address,address)',
+        tx.data,
+      );
+      expect(decoded).toHaveLength(2);
+      expect(decoded[0]).toEqual(STAKE_TOKEN);
+      expect(decoded[1]).toEqual(ALICE);
+    });
+  });
+  describe('claimSelectedRewards', () => {
+    it('should properly create the transaction', () => {
+      const rewards = [REWARD_1, REWARD_2];
+      const tx = stakeTokenService.claimSelectedRewards({
+        stakeToken: STAKE_TOKEN,
+        rewards,
+        sender: ALICE,
+      });
+      expect(tx.from).toEqual(ALICE);
+      expect(tx.to).toEqual(STAKE_TOKEN);
+      expectToBeDefined(tx.gasLimit);
+      expectToBeDefined(tx.data);
+      expect(tx.gasLimit.toString()).toEqual(
+        gasLimitRecommendations[ProtocolAction.umbrellaClaimSelectedRewards]
+          .recommended,
+      );
+      const decoded = stakeTokenInterface.decodeFunctionData(
+        'claimSelectedRewards(address,address[],address)',
+        tx.data,
+      );
+      expect(decoded).toHaveLength(3);
+      expect(decoded[0]).toEqual(STAKE_TOKEN);
+      expect(decoded[1]).toEqual(rewards);
+      expect(decoded[2]).toEqual(ALICE);
+    });
+  });
+});