feat: add usdTieredSTO modifyOracle method and test

Author: Victor Wiebe

src/contract_wrappers/modules/sto/__tests__/usd_tiered_sto_wrapper.test.ts

@@ -2434,6 +2434,72 @@ describe('USDTieredSTOWrapper', () => {
     });
   });
 
+  describe('ModifyOracle', () => {
+    test('should modifyOracle', async () => {
+      // Mock Only Owner and Security Token
+      const expectedOwnerResult = '0x5555555555555555555555555555555555555555';
+      // Security Token Address expected
+      const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
+      // Setup get Security Token Address
+      const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
+      when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
+      when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
+      when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
+        instance(mockedSecurityTokenContract),
+      );
+      const mockedSecurityTokenOwnerMethod = mock(MockedCallMethod);
+      when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
+      when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
+
+      // Mock web3 wrapper owner
+      when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
+
+      const mockedParams = {
+        oracleAddress: '0x1111111111111111111111111111111111111111',
+        fundRaiseType: FundRaiseType.ETH,
+        txData: {},
+        safetyFactor: 10,
+      };
+
+      const expectedResult = getMockedPolyResponse();
+      // Mocked method
+      const mockedMethod = mock(MockedSendMethod);
+      // Stub the method
+      when(mockedContract.modifyOracle).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(
+        mockedMethod.sendTransactionAsync(
+          mockedParams.fundRaiseType,
+          mockedParams.oracleAddress,
+          mockedParams.txData,
+          mockedParams.safetyFactor,
+        ),
+      ).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.modifyOracle(mockedParams);
+
+      // Result expectation
+      expect(result).toBe(expectedResult);
+      // Verifications
+      verify(mockedContract.modifyOracle).once();
+      verify(
+        mockedMethod.sendTransactionAsync(
+          mockedParams.fundRaiseType,
+          mockedParams.oracleAddress,
+          mockedParams.txData,
+          mockedParams.safetyFactor,
+        ),
+      ).once();
+      verify(mockedContract.securityToken).once();
+      verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
+      verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
+      verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
+      verify(mockedSecurityTokenContract.owner).once();
+      verify(mockedWrapper.getAvailableAddressesAsync()).once();
+    });
+  });
+
   describe('ModifyLimits', () => {
     test('should modifyLimits', async () => {
       // Mock Only Owner and Security Token

src/contract_wrappers/modules/sto/usd_tiered_sto_wrapper.ts

@@ -1,21 +1,21 @@
 import {
+  GeneralTransferManagerContract,
   USDTieredSTOContract,
   USDTieredSTOEventArgs,
   USDTieredSTOEvents,
   USDTieredSTOFundsReceivedEventArgs,
   USDTieredSTOPauseEventArgs,
   USDTieredSTOReserveTokenMintEventArgs,
-  USDTieredSTOSetTreasuryWalletEventArgs,
   USDTieredSTOSetAddressesEventArgs,
   USDTieredSTOSetAllowBeneficialInvestmentsEventArgs,
   USDTieredSTOSetFundRaiseTypesEventArgs,
   USDTieredSTOSetLimitsEventArgs,
   USDTieredSTOSetNonAccreditedLimitEventArgs,
   USDTieredSTOSetTiersEventArgs,
   USDTieredSTOSetTimesEventArgs,
+  USDTieredSTOSetTreasuryWalletEventArgs,
   USDTieredSTOTokenPurchaseEventArgs,
   USDTieredSTOUnpauseEventArgs,
-  GeneralTransferManagerContract,
 } from '@polymathnetwork/abi-wrappers';
 import { USDTieredSTO } from '@polymathnetwork/contract-artifacts';
 import { Web3Wrapper } from '@0x/web3-wrapper';
@@ -256,6 +256,14 @@ interface ModifyLimitsParams extends TxParams {
   nonAccreditedLimitUSD: BigNumber;
   minimumInvestmentUSD: BigNumber;
 }
+/**
+ * @param nonAccreditedLimitUSD max non accredited invets limit
+ * @param minimumInvestmentUSD overall minimum investment limit
+ */
+interface ModifyOracleParams extends TxParams {
+  fundRaiseType: FundRaiseType;
+  oracleAddress: string;
+}
 
 /**
  * @param fundRaiseTypes Array of fund raise types to allow
@@ -791,6 +799,23 @@ export default class USDTieredSTOWrapper extends STOWrapper {
     );
   };
 
+  /**
+   * Modifies oracle
+   */
+  public modifyOracle = async (params: ModifyOracleParams) => {
+    assert.assert(await this.isCallerTheSecurityTokenOwner(params.txData), 'The caller must be the ST owner');
+    assert.assert(
+      params.fundRaiseType === FundRaiseType.POLY || params.fundRaiseType === FundRaiseType.ETH,
+      'Invalid currency',
+    );
+    return (await this.contract).modifyOracle.sendTransactionAsync(
+      params.fundRaiseType,
+      params.oracleAddress,
+      params.txData,
+      params.safetyFactor,
+    );
+  };
+
   /**
    * Modifies max non accredited invets limit and overall minimum investment limit
    */