New storage cells in Bridge native contract for base and super events info

rskj-core/src/main/java/co/rsk/peg/Bridge.java

@@ -1532,6 +1532,38 @@ public int setUnionBridgeTransferPermissions(Object[] args) {
         return bridgeSupport.setUnionBridgeTransferPermissions(rskTx, requestEnabled, releaseEnabled).getCode();
     }
 
+    public byte[] getSuperEvent(Object[] args) {
+        logger.trace("getSuperEvent");
+        return bridgeSupport.getSuperEvent();
+    }
+
+    public void setSuperEvent(Object[] args) {
+        logger.trace("setSuperEvent");
+        byte[] data = (byte[]) args[0];
+        bridgeSupport.setSuperEvent(rskTx, data);
+    }
+
+    public void clearSuperEvent(Object[] args) {
+        logger.trace("clearSuperEvent");
+        bridgeSupport.clearSuperEvent(rskTx);
+    }
+
+    public byte[] getBaseEvent(Object[] args) {
+        logger.trace("getBaseEvent");
+        return bridgeSupport.getBaseEvent();
+    }
+
+    public void setBaseEvent(Object[] args) {
+        logger.trace("setBaseEvent");
+        byte[] data = (byte[]) args[0];
+        bridgeSupport.setBaseEvent(rskTx, data);
+    }
+
+    public void clearBaseEvent(Object[] args) {
+        logger.trace("clearBaseEvent");
+        bridgeSupport.clearBaseEvent(rskTx);
+    }
+
     protected static BridgeMethods.BridgeMethodExecutor executeIfAuthorized(
         AuthorizerProvider authorizerProvider,
         BridgeMethods.BridgeMethodExecutor decorate,

rskj-core/src/main/java/co/rsk/peg/BridgeMethods.java

@@ -130,7 +130,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "getBtcBlockchainBestChainHeight",
             new String[]{},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(19000L),
         (BridgeMethodExecutorTyped<Integer>) Bridge::getBtcBlockchainBestChainHeight,
@@ -141,7 +141,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "getBtcBlockchainInitialBlockHeight",
             new String[]{},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(20000L),
         (BridgeMethodExecutorTyped<Integer>) Bridge::getBtcBlockchainInitialBlockHeight,
@@ -324,7 +324,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "getMinimumLockTxValue",
             new String[]{},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(2000L),
         (BridgeMethodExecutorTyped<Long>) Bridge::getMinimumLockTxValue,
@@ -636,7 +636,7 @@ public enum BridgeMethods {
     REGISTER_BTC_TRANSACTION(
         CallTransaction.Function.fromSignature(
             "registerBtcTransaction",
-            new String[]{BYTES, "int", BYTES},
+            new String[]{BYTES, INT, BYTES},
             new String[]{}
         ),
         fixedCost(22000L),
@@ -830,7 +830,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "setUnionBridgeContractAddressForTestnet",
             new String[]{ADDRESS},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(8_000L),
         Bridge.executeIfTestnetAndAuthorized(
@@ -869,7 +869,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "increaseUnionBridgeLockingCap",
             new String[]{UINT256},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(8_000L),
         Bridge.executeIfAuthorized(
@@ -884,7 +884,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "requestUnionBridgeRbtc",
             new String[]{UINT256},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(8_000L),
         (BridgeMethodExecutorTyped<Integer>) Bridge::requestUnionBridgeRbtc,
@@ -895,7 +895,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "releaseUnionBridgeRbtc",
             new String[]{},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(8_000L),
         (BridgeMethodExecutorTyped<Integer>) Bridge::releaseUnionBridgeRbtc,
@@ -906,7 +906,7 @@ public enum BridgeMethods {
         CallTransaction.Function.fromSignature(
             "setUnionBridgeTransferPermissions",
             new String[]{BOOL, BOOL},
-            new String[]{"int"}
+            new String[]{INT}
         ),
         fixedCost(8_000L),
         Bridge.executeIfAuthorized(
@@ -917,6 +917,74 @@ public enum BridgeMethods {
         activations -> activations.isActive(RSKIP502),
         fixedPermission(false)
     ),
+    GET_SUPER_EVENT(
+        CallTransaction.Function.fromSignature(
+          "getSuperEvent",
+          new String[]{},
+          new String[]{BYTES}
+        ),
+        fixedCost(3_000L),
+        (BridgeMethodExecutorTyped<byte[]>) Bridge::getSuperEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false),
+        CallTypeHelper.ALLOW_STATIC_CALL
+    ),
+    SET_SUPER_EVENT(
+        CallTransaction.Function.fromSignature(
+            "setSuperEvent",
+            new String[]{BYTES},
+            new String[]{}
+        ),
+        fixedCost(8_000L),
+        (BridgeMethodExecutorVoid) Bridge::setSuperEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false)
+    ),
+    CLEAR_SUPER_EVENT(
+        CallTransaction.Function.fromSignature(
+            "clearSuperEvent",
+            new String[]{},
+            new String[]{}
+        ),
+        fixedCost(8_000L),
+        (BridgeMethodExecutorVoid) Bridge::clearSuperEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false)
+    ),
+    GET_BASE_EVENT(
+        CallTransaction.Function.fromSignature(
+            "getBaseEvent",
+            new String[]{},
+            new String[]{BYTES}
+        ),
+        fixedCost(3_000L),
+        (BridgeMethodExecutorTyped<byte[]>) Bridge::getBaseEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false),
+        CallTypeHelper.ALLOW_STATIC_CALL
+    ),
+    SET_BASE_EVENT(
+        CallTransaction.Function.fromSignature(
+            "setBaseEvent",
+            new String[]{BYTES},
+            new String[]{}
+        ),
+        fixedCost(8_000L),
+        (BridgeMethodExecutorVoid) Bridge::setBaseEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false)
+    ),
+    CLEAR_BASE_EVENT(
+        CallTransaction.Function.fromSignature(
+            "clearBaseEvent",
+            new String[]{},
+            new String[]{}
+        ),
+        fixedCost(8_000L),
+        (BridgeMethodExecutorVoid) Bridge::clearBaseEvent,
+        activations -> activations.isActive(RSKIP529),
+        fixedPermission(false)
+    ),
     ;
 
     private static class CallTypeHelper {
@@ -925,6 +993,12 @@ private static class CallTypeHelper {
         private static final Predicate<MsgType> RESTRICTED_TO_CALL =  callType -> callType == MsgType.CALL;
     }
 
+    private static final Map<ByteArrayWrapper, BridgeMethods> SIGNATURES = Stream.of(BridgeMethods.values())
+        .collect(Collectors.toMap(
+            m -> new ByteArrayWrapper(m.getFunction().encodeSignature()),
+            Function.identity()
+        ));
+
     private final CallTransaction.Function function;
     private final CostProvider costProvider;
     private final Function<ActivationConfig.ForBlock, Boolean> isEnabledFunction;
@@ -1117,10 +1191,4 @@ private static BridgeCallPermissionProvider fixedPermission(boolean onlyAllowsLo
     private static BridgeCallPermissionProvider fromMethod(BridgeCallPermissionProvider bridgeCallPermissionProvider) {
         return (Bridge bridge, Object[] args) -> bridgeCallPermissionProvider.getOnlyAllowLocalCallsPermission(bridge, args);
     }
-
-    private static final Map<ByteArrayWrapper, BridgeMethods> SIGNATURES = Stream.of(BridgeMethods.values())
-        .collect(Collectors.toMap(
-            m -> new ByteArrayWrapper(m.getFunction().encodeSignature()),
-            Function.identity()
-        ));
 }

rskj-core/src/main/java/co/rsk/peg/BridgeSupport.java

@@ -2941,6 +2941,30 @@ public UnionResponseCode setUnionBridgeTransferPermissions(Transaction tx, boole
         return unionBridgeSupport.setTransferPermissions(tx, requestEnabled, releaseEnabled);
     }
 
+    public byte[] getSuperEvent() {
+        return unionBridgeSupport.getSuperEvent();
+    }
+
+    public void setSuperEvent(Transaction tx, byte[] data) {
+        unionBridgeSupport.setSuperEvent(tx, data);
+    }
+
+    public void clearSuperEvent(Transaction tx) {
+        unionBridgeSupport.clearSuperEvent(tx);
+    }
+
+    public byte[] getBaseEvent() {
+        return unionBridgeSupport.getBaseEvent();
+    }
+
+    public void setBaseEvent(Transaction tx, byte[] data) {
+        unionBridgeSupport.setBaseEvent(tx, data);
+    }
+
+    public void clearBaseEvent(Transaction tx) {
+        unionBridgeSupport.clearBaseEvent(tx);
+    }
+
     protected FlyoverFederationInformation createFlyoverFederationInformation(Keccak256 flyoverDerivationHash) {
         return createFlyoverFederationInformation(flyoverDerivationHash, getActiveFederation());
     }

rskj-core/src/main/java/co/rsk/peg/union/UnionBridgeStorageIndexKey.java

@@ -11,6 +11,8 @@ public enum UnionBridgeStorageIndexKey {
 
     UNION_BRIDGE_REQUEST_ENABLED("unionBridgeRequestEnabled"),
     UNION_BRIDGE_RELEASE_ENABLED("unionBridgeReleaseEnabled"),
+    SUPER_EVENT("superEvent"),
+    BASE_EVENT("baseEvent"),
     ;
 
     private final String key;

rskj-core/src/main/java/co/rsk/peg/union/UnionBridgeStorageProvider.java

@@ -16,5 +16,12 @@ public interface UnionBridgeStorageProvider {
     Optional<Boolean> isUnionBridgeRequestEnabled();
     void setUnionBridgeReleaseEnabled(boolean enabled);
     Optional<Boolean> isUnionBridgeReleaseEnabled();
+    byte[] getSuperEvent();
+    void setSuperEvent(byte[] data);
+    void clearSuperEvent();
+    byte[] getBaseEvent();
+    void setBaseEvent(byte[] data);
+    void clearBaseEvent();
+
     void save();
 }

rskj-core/src/main/java/co/rsk/peg/union/UnionBridgeStorageProviderImpl.java

@@ -2,14 +2,20 @@
 
 import static java.util.Objects.isNull;
 import static java.util.Objects.nonNull;
+import static java.util.Objects.requireNonNull;
+import static org.ethereum.util.ByteUtil.EMPTY_BYTE_ARRAY;
 
 import co.rsk.core.Coin;
 import co.rsk.core.RskAddress;
 import co.rsk.peg.BridgeSerializationUtils;
 import co.rsk.peg.storage.StorageAccessor;
 import java.util.Optional;
+import javax.annotation.Nonnull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class UnionBridgeStorageProviderImpl implements UnionBridgeStorageProvider {
+    private static final Logger logger = LoggerFactory.getLogger(UnionBridgeStorageProviderImpl.class);
 
     private final StorageAccessor bridgeStorageAccessor;
 
@@ -21,6 +27,8 @@ public class UnionBridgeStorageProviderImpl implements UnionBridgeStorageProvide
 
     private Boolean unionBridgeRequestEnabled;
     private Boolean unionBridgeReleaseEnabled;
+    private byte[] superEvent;
+    private byte[] baseEvent;
 
     public UnionBridgeStorageProviderImpl(StorageAccessor bridgeStorageAccessor) {
         this.bridgeStorageAccessor = bridgeStorageAccessor;
@@ -33,6 +41,8 @@ public void save() {
         saveWeisTransferredToUnionBridge();
         saveRequestEnabled();
         saveReleaseEnabled();
+        saveSuperEvent();
+        saveBaseEvent();
     }
 
     private void saveReleaseEnabled() {
@@ -189,4 +199,76 @@ public Optional<Boolean> isUnionBridgeReleaseEnabled() {
                 BridgeSerializationUtils::deserializeBoolean
             )));
     }
+
+    @Override
+    public byte[] getSuperEvent() {
+        if (!isNull(superEvent)) {
+            return superEvent.clone();
+        }
+
+        superEvent = bridgeStorageAccessor.getFromRepository(
+            UnionBridgeStorageIndexKey.SUPER_EVENT.getKey(),
+            data -> data
+        );
+        return Optional.ofNullable(superEvent).orElse(EMPTY_BYTE_ARRAY);
+    }
+
+    @Override
+    public void setSuperEvent(@Nonnull byte[] data) {
+        requireNonNull(data, "Super event data cannot be null");
+        this.superEvent = data.clone();
+    }
+
+    @Override
+    public void clearSuperEvent() {
+        logger.info("[clearSuperEvent] Clearing super event.");
+        setSuperEvent(EMPTY_BYTE_ARRAY);
+    }
+
+    private void saveSuperEvent() {
+        if (isNull(superEvent)) {
+            return;
+        }
+
+        bridgeStorageAccessor.saveToRepository(
+            UnionBridgeStorageIndexKey.SUPER_EVENT.getKey(),
+            superEvent
+        );
+    }
+
+    @Override
+    public byte[] getBaseEvent() {
+        if (!isNull(baseEvent)) {
+            return baseEvent.clone();
+        }
+
+        baseEvent = bridgeStorageAccessor.getFromRepository(
+            UnionBridgeStorageIndexKey.BASE_EVENT.getKey(),
+            data -> data
+        );
+        return Optional.ofNullable(baseEvent).orElse(EMPTY_BYTE_ARRAY);
+    }
+
+    @Override
+    public void setBaseEvent(@Nonnull byte[] data) {
+        requireNonNull(data, "Base event data cannot be null");
+        this.baseEvent = data.clone();
+    }
+
+    @Override
+    public void clearBaseEvent() {
+        logger.info("[clearBaseEvent] Clearing base event.");
+        setBaseEvent(EMPTY_BYTE_ARRAY);
+    }
+
+    private void saveBaseEvent() {
+        if (isNull(baseEvent)) {
+            return;
+        }
+
+        bridgeStorageAccessor.saveToRepository(
+            UnionBridgeStorageIndexKey.BASE_EVENT.getKey(),
+            baseEvent
+        );
+    }
 }