updated xc controller interface

Author: aalavandhan

contracts/satellite-chain/xc-ampleforth/XCAmpleController.sol

@@ -13,6 +13,7 @@ import {
 
 import {UInt256Lib} from "./UInt256Lib.sol";
 import {IXCAmple} from "../../_interfaces/IXCAmple.sol";
+import {IXCAmpleSupplyPolicy} from "../../_interfaces/IXCAmpleSupplyPolicy.sol";
 import {IBatchTxExecutor} from "../../_interfaces/IBatchTxExecutor.sol";
 
 /**
@@ -113,7 +114,7 @@ contract XCAmpleController is OwnableUpgradeable {
      * @param xcAmpleAmount The amount of xcAmples to be mint on this chain.
      */
     function mint(address recipient, uint256 xcAmpleAmount) external onlyBridgeGateway {
-        IXCAmple(xcAmple).mint(recipient, xcAmpleAmount);
+        IXCAmpleSupplyPolicy(xcAmple).mint(recipient, xcAmpleAmount);
         emit GatewayMint(msg.sender, recipient, xcAmpleAmount);
     }
 
@@ -125,7 +126,7 @@ contract XCAmpleController is OwnableUpgradeable {
      * @param xcAmpleAmount The amount of xcAmples to be burnt on this chain.
      */
     function burn(address depositor, uint256 xcAmpleAmount) external onlyBridgeGateway {
-        IXCAmple(xcAmple).burn(depositor, xcAmpleAmount);
+        IXCAmpleSupplyPolicy(xcAmple).burn(depositor, xcAmpleAmount);
         emit GatewayBurn(msg.sender, depositor, xcAmpleAmount);
     }
 
@@ -149,6 +150,19 @@ contract XCAmpleController is OwnableUpgradeable {
         );
     }
 
+    /**
+     * @notice A multi-chain AMPL interface method. The Ampleforth monetary policy contract
+     *         on the base-chain and XCAmpleController contracts on the satellite-chains
+     *         implement this method. It atomically returns two values:
+     *         what the current contract believes to be,
+     *         the globalAmpleforthEpoch and globalAMPLSupply.
+     * @return globalAmpleforthEpoch The recorded global Ampleforth epoch.
+     * @return globalAMPLSupply The recorded global AMPL supply.
+     */
+    function globalAmpleforthEpochAndAMPLSupply() external view returns (uint256, uint256) {
+        return (globalAmpleforthEpoch, IXCAmple(xcAmple).globalAMPLSupply());
+    }
+
     /**
      * @notice Initiate a new rebase operation.
      * @dev Once the Bridge gateway reports new epoch and total supply Rebase can be triggered on this satellite chain.
@@ -168,7 +182,7 @@ contract XCAmpleController is OwnableUpgradeable {
         int256 recordedGlobalAMPLSupply = IXCAmple(xcAmple).globalAMPLSupply().toInt256Safe();
 
         // execute rebase on this chain
-        IXCAmple(xcAmple).rebase(nextGlobalAmpleforthEpoch, nextGlobalAMPLSupply);
+        IXCAmpleSupplyPolicy(xcAmple).rebase(nextGlobalAmpleforthEpoch, nextGlobalAMPLSupply);
 
         // calculate supply delta
         int256 supplyDelta = nextGlobalAMPLSupply.toInt256Safe().sub(recordedGlobalAMPLSupply);

test/unit/satellite-chain/xc-ampleforth/xc_controller.js

@@ -15,6 +15,8 @@ async function setupContracts () {
     .connect(deployer)
     .deploy();
 
+  await mockToken.updateGlobalAMPLSupply(39992123);
+
   // deploy upgradable token
   const factory = await ethers.getContractFactory(
     'contracts/satellite-chain/xc-ampleforth/XCAmpleController.sol:XCAmpleController',
@@ -42,6 +44,12 @@ describe('XCAmpleController:Initialization', () => {
   it('should set the owner', async function () {
     expect(await controller.owner()).to.eq(await deployer.getAddress());
   });
+
+  it('should return the globalAmpleforthEpochAndAMPLSupply', async function () {
+    const r = await controller.globalAmpleforthEpochAndAMPLSupply();
+    expect(r[0]).to.eq(1);
+    expect(r[1]).to.eq('39992123');
+  });
 });
 
 describe('XCAmpleController:setRebaseRelayer', async () => {

test/unit/satellite-chain/xc-ampleforth/xc_controller_rebase.js

@@ -81,6 +81,14 @@ describe('XCAmpleController:rebase', async () => {
     expect(await controller.globalAmpleforthEpoch()).to.eq(2);
   });
 
+  it('should update globalAmpleforthEpochAndAMPLSupply', async function () {
+    await controller.connect(bridge).reportRebase(2, 50626634);
+    await controller.connect(rebaseCaller).rebase();
+    const r = await controller.globalAmpleforthEpochAndAMPLSupply();
+    expect(r[0]).to.eq('2');
+    expect(r[1]).to.eq('50626634');
+  });
+
   it('should update lastRebaseTimestampSec', async function () {
     const t1 = await controller.lastRebaseTimestampSec();
     await increaseTime(3600);