feat: add ICS20 App on IBC

contracts/javascore/ibc/src/main/java/ibc/ics20/app/ICS20Bank.java

@@ -0,0 +1,104 @@
+package ibc.ics20.app;
+
+import ibc.ics24.host.IBCCommitment;
+import score.Address;
+import score.BranchDB;
+import score.Context;
+import score.DictDB;
+import score.annotation.External;
+
+import java.math.BigInteger;
+
+public class ICS20Bank {
+
+    private static final byte[] ADMIN_ROLE = IBCCommitment.keccak256("ADMIN_ROLE".getBytes());
+    private static final byte[] OPERATOR_ROLE = IBCCommitment.keccak256("OPERATOR_ROLE".getBytes());
+
+    private static final Integer ADMIN_ROLE_ID = 1;
+    private static final Integer OPERATOR_ROLE_ID = 2;
+
+
+    // Mapping from token ID to account balances
+    private final BranchDB<String, DictDB<Address, BigInteger>> balances = Context.newBranchDB("BALANCES", BigInteger.class);
+    private final DictDB<Address, Integer> roles = Context.newDictDB("ROLES", Integer.class);
+
+
+    public ICS20Bank() {
+        setupRole(ADMIN_ROLE_ID, Context.getCaller());
+    }
+
+    @External
+    public void setupRole(Integer role, Address account) {
+        Context.require(Context.getCaller().equals(Context.getOwner()), "Only owner can set up role");
+        roles.set(account, role);
+    }
+
+    @External
+    public void setupOperator(Address account) {
+        setupRole(OPERATOR_ROLE_ID, account);
+    }
+
+    private boolean hasRole(Integer role, Address account) {
+        return (role == roles.getOrDefault(account, 0));
+    }
+
+    @External(readonly = true)
+    public BigInteger balanceOf(Address account, String denom) {
+        Context.require(account != ICS20Transfer.ZERO_ADDRESS, "ICS20Bank: balance query for the zero address");
+
+        // Assuming the denomination is a valid key in the balances mapping
+        return balances.at(denom).getOrDefault(account, BigInteger.ZERO);
+    }
+
+    @External
+    public void transferFrom(Address from, Address to, String denom, BigInteger amount) {
+        Context.require(to != ICS20Transfer.ZERO_ADDRESS, "ICS20Bank: balance query for the zero address");
+        Address caller = Context.getCaller();
+        Context.require(from.equals(caller) || hasRole(OPERATOR_ROLE_ID, caller), "ICS20Bank: caller is not owner nor approved");
+        BigInteger fromBalance = balanceOf(from, denom);
+        Context.require(amount.compareTo(BigInteger.ZERO) > 0, "ICS20Bank: transfer amount must be greater than zero");
+        Context.require(fromBalance.compareTo(amount) >= 0, "ICS20Bank: insufficient balance for transfer");
+
+        balances.at(denom).set(from, fromBalance.subtract(amount));
+        balances.at(denom).set(to, balanceOf(to, denom).add(amount));
+    }
+
+    @External
+    public void mint(Address account, String denom, BigInteger amount) {
+        Context.require(hasRole(OPERATOR_ROLE_ID, Context.getCaller()), "ICS20Bank: must have minter role to mint");
+        Context.require(account != ICS20Transfer.ZERO_ADDRESS, "ICS20Bank: mint to the zero address");
+        Context.require(amount.compareTo(BigInteger.ZERO) > 0, "ICS20Bank: mint amount must be greater than zero");
+        _mint(account, denom, amount);
+    }
+
+    @External
+    public void burn(Address account, String denom, BigInteger amount) {
+        Context.require(hasRole(OPERATOR_ROLE_ID, Context.getCaller()), "ICS20Bank: must have minter role to mint");
+        Context.require(amount.compareTo(BigInteger.ZERO) > 0, "ICS20Bank: mint amount must be greater than zero");
+        _burn(account, denom, amount);
+    }
+
+    @External
+    public void deposit(Address tokenContract, BigInteger amount, Address receiver){
+        Context.require(tokenContract.isContract(), "ICS20Bank: tokenContract is not a contract");
+        Context.call(tokenContract, "transferFrom", Context.getCaller(), Context.getAddress(), amount);
+        _mint(receiver, tokenContract.toString(), amount);
+    }
+
+    @External
+    public void withdraw(Address tokenContract, BigInteger amount, Address receiver){
+        Context.require(tokenContract.isContract(), "ICS20Bank: tokenContract is not a contract");
+        _burn(receiver, tokenContract.toString(), amount);
+        Context.call(tokenContract, "transfer", receiver, amount);
+    }
+
+    private void _mint(Address account, String denom,  BigInteger amount){
+        balances.at(denom).set(account, balanceOf(account, denom).add(amount));
+    }
+
+    private void _burn(Address account, String denom,  BigInteger amount){
+        BigInteger accountBalance = balanceOf(account, denom);
+        Context.require(accountBalance.compareTo(amount) >= 0, "ICS20Bank: burn amount exceeds balance");
+        balances.at(denom).set(account, accountBalance.subtract(amount));
+    }
+}

contracts/javascore/ibc/src/main/java/ibc/ics20/app/ICS20Lib.java

@@ -0,0 +1,84 @@
+package ibc.ics20.app;
+
+import score.Address;
+import score.Context;
+
+import java.math.BigInteger;
+
+public class ICS20Lib {
+
+    public static class PacketData {
+        public String denom;
+        public String sender;
+        public String receiver;
+        public BigInteger amount;
+        public String memo;
+    }
+
+
+    public static final byte[] SUCCESSFUL_ACKNOWLEDGEMENT_JSON = "{\"result\":\"AQ==\"}".getBytes();
+    public static final byte[] FAILED_ACKNOWLEDGEMENT_JSON = "{\"error\":\"failed\"}".getBytes();
+//    bytes32 public constant KECCAK256_SUCCESSFUL_ACKNOWLEDGEMENT_JSON = keccak256(SUCCESSFUL_ACKNOWLEDGEMENT_JSON);
+
+//    public static final Integer CHAR_DOUBLE_QUOTE = 0x22;
+    public static final Integer CHAR_SLASH = 0x2f;
+    public static final Integer CHAR_BACKSLASH = 0x5c;
+    public static final Integer CHAR_F = 0x66;
+    public static final Integer CHAR_R = 0x72;
+    public static final Integer CHAR_N = 0x6e;
+    public static final Integer CHAR_B = 0x62;
+    public static final Integer CHAR_T = 0x74;
+    public static final Integer CHAR_CLOSING_BRACE = 0x7d;
+    public static final Integer CHAR_M = 0x6d;
+    private static final char[] HEX_DIGITS = "0123456789abcdef".toCharArray();
+
+    private static final int CHAR_DOUBLE_QUOTE = '"';
+
+    // Function to check if escape is needed for a byte array in Java
+    static boolean isEscapeNeededString(byte[] bz) {
+        for (int i = 0; i < bz.length; i++) {
+            int c = bz[i] & 0xFF; // Convert to unsigned int
+            if (c == CHAR_DOUBLE_QUOTE) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+
+    public static byte[] marshalJson(String escapedDenom, BigInteger amount, String escapedSender, String escapedReceiver) {
+        String jsonString = "{\"amount\":\"" +
+                amount.toString() +
+                "\",\"denom\":\"" +
+                escapedDenom +
+                "\",\"receiver\":\"" +
+                escapedReceiver +
+                "\",\"sender\":\"" +
+                escapedSender +
+                "\"}";
+
+        return jsonString.getBytes();
+    }
+
+    static String addressToHexString(String addr) {
+        StringBuilder hexString = new StringBuilder("0x");
+        long localValue = Long.parseLong(addr.substring(2), 16);
+
+        for (int i = 39; i >= 0; --i) {
+            hexString.append(HEX_DIGITS[(int) (localValue & 0xf)]);
+            localValue >>= 4;
+        }
+
+        if (localValue != 0) {
+            Context.revert("Insufficient hex length");
+        }
+
+        return hexString.toString();
+    }
+
+
+
+
+
+}

contracts/javascore/ibc/src/main/java/ibc/ics20/app/ICS20Transfer.java

@@ -0,0 +1,179 @@
+package ibc.ics20.app;
+
+import ibc.icon.interfaces.IIBCModule;
+import ibc.icon.score.util.Logger;
+import ibc.icon.score.util.StringUtil;
+import ibc.ics05.port.ModuleManager;
+import ibc.ics25.handler.IBCHandler;
+
+import icon.proto.core.channel.Channel;
+import icon.proto.core.channel.Packet;
+import score.Address;
+import score.Context;
+import score.DictDB;
+import score.annotation.External;
+
+import java.math.BigInteger;
+import java.util.Map;
+
+public class ICS20Transfer {
+    public static String ICS20_VERSION = "ics20-1";
+    public static Address ZERO_ADDRESS = Address.fromString("hx0000000000000000000000000000000000000000");
+
+
+    public static final DictDB<String, Address> channelEscrowAddresses = Context.newDictDB("channelEscrowAddresses", Address.class);
+
+
+    @External
+    public byte[] onRecvPacket(byte[] packet, Address relayer) {
+//        TODO unmarshal json
+        boolean success = false;
+        Address receiver = ZERO_ADDRESS;
+        receiver, success = _decodeReceiver(packet.data.receiver);
+        if (!success) {
+           return ICS20Lib.FAILED_ACKNOWLEDGEMENT_JSON;
+        }
+
+        byte[] denomPrefix = getDenomPrefix(packet.data.sourcePort, packet.data.sourceChannel);
+        byte[] denom = packet.data.denom.getBytes();
+        if (denom.length >= denomPrefix.length) {
+//            denom slicing todo
+            success = _transferFrom(getEscrowAddress(packet.data.sourceChannel), receiver, packet.data.denom, packet.data.amount);
+        } else{
+            if(ICS20Lib.isEscapeNeededString(denom)){
+                success = false;
+            }else{
+                success = _mint(receiver, String(getDenomPrefix(packet.destination_port, packet.destination_channel), denom), packet.data.amount);
+            }
+        }
+
+        if (success) {
+            return ICS20Lib.SUCCESSFUL_ACKNOWLEDGEMENT_JSON;
+        }else{
+            return ICS20Lib.FAILED_ACKNOWLEDGEMENT_JSON;
+        }
+
+
+        return packet;
+    }
+
+
+    @External
+    public void onAcknowledgementPacket(byte[] calldata, byte[] acknowledgement, Address relayer) {
+        Context.println("onAcknowledgementPacket");
+//        Context.require(Context.getCaller().equals(getIBCAddress()), "caller is not handler");
+        if (acknowledgement != ICS20Lib.SUCCESSFUL_ACKNOWLEDGEMENT_JSON) {
+                refundTokens(calldata, packet.source_port, packet.source_channel);
+        }
+
+    }
+
+    @External
+    public String onChanOpenInit(IIBCModule.onChanOpenInit msg) {
+//        srcChan.set(channelId);
+//        srcPort.set(portId);
+//        Channel.Counterparty counterparty = Channel.Counterparty.decode(counterpartyPb);
+//        dstPort.set(counterparty.getPortId());
+//        Context.println("onChanOpenInit");
+        return ICS20_VERSION;
+    }
+
+    @External
+    public String onChanOpenTry(IIBCModule.onChanOpenTry msg) {
+        return ICS20_VERSION;
+    }
+
+    @External
+    public void onChanOpenAck(IIBCModule.MsgOnChanOpenAck msg) {
+
+    }
+
+    @External
+    public void onChanCloseInit(IIBCModule.MsgOnChanCloseInit msg) {
+        Context.revert("Not Allowed");
+    }
+
+    @External
+    public void onTimeoutPacket(Packet packet, byte[] proofHeight, byte[] proof, BigInteger nextSequenceRecv) {
+    }
+
+
+    static Address getEscrowAddress(String sourceChannel) {
+        Address escorw = channelEscrowAddresses.get(sourceChannel);
+        Context.require(escorw != ZERO_ADDRESS);
+        return escorw;
+    }
+
+    private void refundTokens(ICS20Lib.PacketData data, String sourcePort, String sourceChannel) {
+        byte[] denomPrefix = getDenomPrefix(sourcePort, sourceChannel);
+        byte[] denom = data.denom.getBytes();
+
+        if (denom.length >= denomPrefix.length) {
+
+            Context.println("if");
+        } else {
+            Context.println("else");
+        }
+
+
+    }
+
+    public static byte[] getDenomPrefix(String port, String channel) {
+        return StringUtil.encodePacked(port, "/", channel, "/");
+    }
+
+    protected boolean _transferFrom(Address sender, Address receiver, String denom, BigInteger amount) {
+        // Implementation goes here
+        // Return true if minting is successful, false otherwise
+        return true;
+    }
+
+    protected boolean _mint(Address account, String denom, BigInteger amount) {
+        // Implementation goes here
+        // Return true if minting is successful, false otherwise
+        return true;
+    }
+
+    /**
+     * @dev _burn burns tokens from `account` in the bank.
+     */
+    protected boolean _burn(Address account, String denom, BigInteger amount) {
+        // Implementation goes here
+        // Return true if burning is successful, false otherwise
+        return true;
+    }
+
+    /**
+     * @dev _encodeSender encodes an address to a hex string.
+     * The encoded sender is used as `sender` field in the packet data.
+     */
+    protected static String _encodeSender(Address sender) {
+        return ICS20Lib.addressToHexString(sender.toString());
+    }
+
+
+    protected Address _decodeSender(String sender) {
+//        Map<Address, Boolean> result = ICS20Lib.hexStringToAddress(sender);
+//        require(result.getSecond(), "invalid address");
+//        return result.getFirst();
+        return (ZERO_ADDRESS);
+    }
+
+    /**
+     * @dev _decodeReceiver decodes a hex string to an address.
+     * `receiver` may be an invalid address format.
+     */
+    protected Map<Address, Boolean> _decodeReceiver(String receiver) {
+        boolean flag;
+        try {
+            Address.fromString(receiver);
+            flag = true;
+        } catch (Exception e) {
+            flag = false;
+
+        }
+        return Map.of(Address.fromString(receiver), flag);
+    }
+
+
+}