diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/GeneralizedConnection.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/GeneralizedConnection.java index 7f8036f8..716ddbc0 100644 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/GeneralizedConnection.java +++ b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/GeneralizedConnection.java @@ -57,7 +57,6 @@ public BigInteger getConnSn() { } void onlyRelay() { - Context.println(relayAddress.get().toString()); Context.require(Context.getCaller().equals(relayAddress.get()), "OnlyRelayer"); } diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/Intent.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/Intent.java index 484f85c4..f512b3a7 100644 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/Intent.java +++ b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/Intent.java @@ -3,35 +3,28 @@ import java.math.BigInteger; import java.util.Arrays; -import network.icon.intent.constants.Constant; -import network.icon.intent.structs.Cancel; +import static network.icon.intent.constants.Constant.*; +import network.icon.intent.constants.Constant.OrderAction; +import network.icon.intent.db.SwapOrderDb; import network.icon.intent.structs.OrderFill; import network.icon.intent.structs.OrderMessage; -import network.icon.intent.structs.SwapOrder; -import network.icon.intent.utils.SwapOrderData; +import network.icon.intent.structs.TokenFallbackData; import score.*; import score.annotation.EventLog; import score.annotation.External; -import score.annotation.Payable; -import com.eclipsesource.json.Json; -import com.eclipsesource.json.JsonObject; public class Intent extends GeneralizedConnection { - public final VarDB depositId = Context.newVarDB(Constant.DEPOSIT_ID, BigInteger.class); - public final VarDB networkId = Context.newVarDB(Constant.NETWORK_ID, String.class); - public final VarDB protocolFee = Context.newVarDB(Constant.PROTOCOL_FEE, BigInteger.class); - public static final VarDB
feeHandler = Context.newVarDB(Constant.FEE_HANDLER, Address.class); - public static final VarDB
owner = Context.newVarDB(Constant.OWNER, Address.class); - // public final VarDB
nativeAddress = - // Context.newVarDB(Constant.NATIVE_ADDRESS, Address.class); - // final static BranchDB> deposit = - // Context.newBranchDB(Constant.DEPOSIT, - // BigInteger.class); - final static DictDB orders = Context.newDictDB(Constant.ORDERS, SwapOrder.class); - final static DictDB finishedOrders = Context.newDictDB(Constant.FINISHED_ORDERS, Boolean.class); - - public static Address nativeAddress = Address.fromString("cx0000000000000000000000000000000000000000"); + public final VarDB depositId = Context.newVarDB(DEPOSIT_ID, BigInteger.class); + public final VarDB networkId = Context.newVarDB(NETWORK_ID, String.class); + public final VarDB protocolFee = Context.newVarDB(PROTOCOL_FEE, BigInteger.class); + public static final VarDB
feeHandler = Context.newVarDB(FEE_HANDLER, Address.class); + final static DictDB orders = Context.newDictDB(ORDERS, SwapOrderDb.class); + final static DictDB finishedOrders = Context.newDictDB(FINISHED_ORDERS, Boolean.class); + public static BigInteger divideFactor = BigInteger.valueOf(10_000); + + public static final String SWAP = "swap"; + public static final String FILL = "fill"; @EventLog(indexed = 3) public void SwapIntent( @@ -61,46 +54,44 @@ public void OrderClosed(BigInteger id) { } public Intent(String _nid, BigInteger _protocolFee, Address _feeHandler, Address _relayer) { - networkId.set(_nid); - protocolFee.set(_protocolFee); - feeHandler.set(_feeHandler); - relayAddress.set(_relayer); - // nativeAddress.set(Address.fromString("cx0000000000000000000000000000000000000000")); - owner.set(Context.getOwner()); + if (networkId.get() == null) { + networkId.set(_nid); + protocolFee.set(_protocolFee); + feeHandler.set(_feeHandler); + relayAddress.set(_relayer); + } } @External - @Payable - public void swap(SwapOrderData swapOrderData) { - Context.require(swapOrderData.token != null, "Token can't be null"); - Context.require(Context.getCaller().toString().equals(swapOrderData.creator), - "Creator must be sender"); - Context.require(Context.getValue().equals(swapOrderData.amount), - "Deposit amount not equal to order amount"); - - Address token = Address.fromString(swapOrderData.token); - // Address nativAddress = nativeAddress.get(); - Context.require(token.equals(nativeAddress), "Not a native token"); - - SwapOrder swapOrder = new SwapOrder(swapOrderData.id, swapOrderData.emitter, - swapOrderData.srcNID, - swapOrderData.dstNID, swapOrderData.creator, - swapOrderData.destinationAddress, swapOrderData.token, - swapOrderData.amount, swapOrderData.toToken, swapOrderData.toAmount, - swapOrderData.data); - - // deposit.at(swapOrderData.creator).set(swapOrderData.token, - // swapOrderData.amount); - - _swap(swapOrder); + public void tokenFallback(Address _from, BigInteger _value, byte[] _data) { + TokenFallbackData fallbackData = TokenFallbackData.fromBytes(_data); + SwapOrderDb swapOrder = SwapOrderDb.fromBytes(fallbackData.swapOrderData); + String type = fallbackData.type; + + switch (type) { + case SWAP: + Context.require(_value.equals(swapOrder.amount), "Value and amount must be equal"); + Context.require(_from.toString().equals(swapOrder.creator), "Depositer must be creator"); + _swap(swapOrder); + break; + + case FILL: + Address solver = fallbackData.solver; + _fill(swapOrder, solver.toString()); + break; + + default: + Context.revert("Message type mismatched(swap/fill)"); + ; + } + } - void _swap(SwapOrder swapOrder) { + void _swap(SwapOrderDb swapOrder) { BigInteger id = this.depositId.getOrDefault(BigInteger.ZERO).add(BigInteger.valueOf(1)); swapOrder.id = id; Context.require(swapOrder.srcNID.equals(this.networkId.get()), "NID is misconfigured"); - Context.require(swapOrder.emitter.equals(Context.getAddress().toString()), - "Emitter specified is not this"); // emitter contract or eoa? + Context.require(swapOrder.emitter.equals(Context.getAddress().toString()), "Emitter specified is not this"); orders.set(id, swapOrder); SwapIntent(id, swapOrder.emitter, swapOrder.srcNID, swapOrder.dstNID, swapOrder.creator, @@ -109,12 +100,7 @@ void _swap(SwapOrder swapOrder) { swapOrder.data); } - @External - @Payable - public void fill(SwapOrderData swapOrderData, String solverAddress) { - SwapOrder swapOrder = new SwapOrder(swapOrderData.id, swapOrderData.emitter, swapOrderData.srcNID, - swapOrderData.dstNID, swapOrderData.creator, swapOrderData.destinationAddress, swapOrderData.token, - swapOrderData.amount, swapOrderData.toToken, swapOrderData.toAmount, swapOrderData.data); + void _fill(SwapOrderDb swapOrder, String solverAddress) { byte[] orderBytes = swapOrder.toBytes(); byte[] orderHash = Context.hash("keccak-256", orderBytes); @@ -124,8 +110,7 @@ public void fill(SwapOrderData swapOrderData, String solverAddress) { Context.require(!isFilled, "Order has already been filled"); finishedOrders.set(orderHash, true); - BigInteger fee = swapOrder.toAmount.multiply(protocolFee.get()).divide(BigInteger.valueOf(10000)); // add divide - // by 10000 + BigInteger fee = swapOrder.toAmount.multiply(protocolFee.get()).divide(divideFactor); BigInteger toAmount = swapOrder.toAmount.subtract(fee); _transferResult(swapOrder.destinationAddress, swapOrder.toToken, toAmount, @@ -137,14 +122,14 @@ public void fill(SwapOrderData swapOrderData, String solverAddress) { _resolveFill(networkId.get(), orderFill); return; } - OrderMessage orderMessage = new OrderMessage(Constant.FILL, orderHash); + OrderMessage orderMessage = new OrderMessage(OrderAction.FILL.getValue(), orderHash); _sendMessage(swapOrder.srcNID, Context.hash("keccak-256", orderMessage.toBytes())); OrderFilled(swapOrder.id, swapOrder.srcNID); } @External public void cancel(BigInteger id) { - SwapOrder order = orders.get(id); + SwapOrderDb order = orders.get(id); if (order == null) { Context.revert("Order already has been cancelled"); } @@ -152,14 +137,12 @@ public void cancel(BigInteger id) { "Only creator can cancel this order"); if (order.srcNID.equals(order.dstNID)) { - _resolveCancel(nativeAddress.toString(), order.toBytes()); + _resolveCancel(networkId.get(), order.toBytes()); return; } - Cancel cancel = new Cancel(); - cancel.orderBytes = order.toBytes(); + OrderMessage _msg = new OrderMessage(OrderAction.CANCEL.getValue(), order.toBytes()); - OrderMessage _msg = new OrderMessage(Constant.CANCEL, cancel.orderBytes); _sendMessage(order.dstNID, _msg.toBytes()); } @@ -169,12 +152,11 @@ public void recvMessage(String srcNetwork, BigInteger _connSn, byte[] _msg) { OrderMessage orderMessage = OrderMessage.fromBytes(_msg); - if (orderMessage.messageType.equals(Constant.FILL)) { + if (orderMessage.messageType.equals(OrderAction.FILL.getValue())) { OrderFill _fill = OrderFill.fromBytes(orderMessage.message); _resolveFill(srcNetwork, _fill); - } else if (orderMessage.messageType.equals(Constant.CANCEL)) { - Cancel _cancel = Cancel.fromBytes(orderMessage.message); - _resolveCancel(srcNetwork, _cancel.orderBytes); + } else if (orderMessage.messageType.equals(OrderAction.CANCEL.getValue())) { + _resolveCancel(srcNetwork, orderMessage.message); } } @@ -184,15 +166,15 @@ void _resolveCancel(String srcNetwork, byte[] orderBytes) { return; } - SwapOrder order = SwapOrder.fromBytes(orderBytes); + SwapOrderDb order = SwapOrderDb.fromBytes(orderBytes); - Context.require(order.srcNID.equals(srcNetwork), "Invalid Network"); + Context.require(order.srcNID.equals(networkId.get()), "Invalid Network"); finishedOrders.set(orderHash, true); OrderFill _fill = new OrderFill(order.id, orderBytes, order.creator); - OrderMessage _msg = new OrderMessage(Constant.FILL, _fill.toBytes()); + OrderMessage _msg = new OrderMessage(OrderAction.FILL.getValue(), _fill.toBytes()); _sendMessage(order.srcNID, _msg.toBytes()); @@ -200,7 +182,7 @@ void _resolveCancel(String srcNetwork, byte[] orderBytes) { } void _resolveFill(String srcNetwork, OrderFill _fill) { - SwapOrder order = orders.get(_fill.id); + SwapOrderDb order = orders.get(_fill.id); if (order == null) { Context.revert("There is no order to resolve"); } @@ -215,83 +197,17 @@ void _resolveFill(String srcNetwork, OrderFill _fill) { OrderClosed(_fill.id); Address tokenAddress = Address.fromString(order.token); - if (tokenAddress.equals(nativeAddress)) { - Context.transfer(Address.fromString(_fill.solver), order.amount); - } else { - Context.call(tokenAddress, "transfer", Address.fromString(_fill.solver), order.amount); - } + Context.call(tokenAddress, "transfer", Address.fromString(_fill.solver), order.amount); } void _transferResult(String _toAddress, String _toToken, BigInteger amount, BigInteger fee) { Address toAddress = Address.fromString(_toAddress); Address toTokenAddress = Address.fromString(_toToken); - if (toTokenAddress.equals(nativeAddress)) { - Context.require(Context.getValue().equals(amount.add(fee)), "\"Deposit amount not equal to order amount\""); - _nativeTransfer(toAddress, amount); - _nativeTransfer(feeHandler.get(), fee); - } else { - Context.call(toTokenAddress, "transfer", toAddress, - amount); - Context.call(toTokenAddress, "transfer", - feeHandler.get(), fee); - } - } - - void _nativeTransfer(Address to, BigInteger amount) { - Context.transfer(to, amount); - } - - @External - public void tokenFallback(Address _from, BigInteger _value, byte[] _data) { - Context.require(_value.compareTo(BigInteger.ZERO) > 0, "Zero transfers not allowed"); - - String unpackedData = new String(_data); - Context.require(!unpackedData.equals(""), "Token Fallback: Data can't be empty"); - JsonObject json = Json.parse(unpackedData).asObject(); - - // string(address of depositer) -> string (deposits token address) -> amountof - // token - // String depositor = json.get("depositor").asString(); - // String token = json.get("token").asString(); - // BigInteger amount = new BigInteger(json.get("amount").asString()); - SwapOrder swapOrder = SwapOrder - .fromBytes(hexStringToByteArray(json.get("swapOrderDataBytes").asString())); - Context.require(_value.equals(swapOrder.amount), "Value and amount must be equal"); - Context.require(_from.toString().equals(swapOrder.creator), "Depositer must be creator"); - String type = json.get("type").asString(); - // token validated context.getCaller() - // deposit.at(depositor).set(token, amount); - if (type.equals("swap")) { - - // deposit.at(swapOrder.creator).set(swapOrder.token, swapOrder.amount); - - // Context.require(amount.equals(swapOrder.amount), "Token amount must be - // equal"); - // Context.require(swapOrder.getToken() != null, "Token can't be null"); - // Context.require(Context.getCaller().toString().equals(swapOrder.getCreator()), - // "Creator must be sender"); - _swap(swapOrder); - } else { - - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; - - String solver = json.get("solver").asString(); - fill(swapOrderData, solver); - } - ; - + Context.call(toTokenAddress, "transfer", toAddress, + amount); + Context.call(toTokenAddress, "transfer", + feeHandler.get(), fee); } @External @@ -315,7 +231,7 @@ public Address getFeeHandler() { return feeHandler.get(); } - public static SwapOrder getOrders(BigInteger id) { + public static SwapOrderDb getOrders(BigInteger id) { return orders.get(id); } @@ -323,33 +239,7 @@ public static Boolean getFinishedorders(byte[] messageHash) { return finishedOrders.getOrDefault(messageHash, false); } - // public static BigInteger getDepositAmount(String depositer, String token) { - // return deposit.at(depositer).getOrDefault(token, BigInteger.ZERO); - // } - static void OnlyOwner() { - Context.require(owner.get().equals(Context.getCaller()), "Not Owner"); - } - - // public static String extractAddress(String input) { - // if (input.contains("0x2.icon/")) { - // int lastSlashIndex = input.lastIndexOf('/'); - // if (lastSlashIndex != -1 && lastSlashIndex < input.length() - 1) { - // return input.substring(lastSlashIndex + 1); - // } - // } else { - // return input; - // } - // return null; - // } - - public static byte[] hexStringToByteArray(String s) { - int len = s.length(); - byte[] data = new byte[len / 2]; - for (int i = 0; i < len; i += 2) { - data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) - + Character.digit(s.charAt(i + 1), 16)); - } - return data; + Context.require(Context.getOwner().equals(Context.getCaller()), "Not Owner"); } -} +} \ No newline at end of file diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/constants/Constant.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/constants/Constant.java index 16b0b43d..9b0f61a1 100644 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/constants/Constant.java +++ b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/constants/Constant.java @@ -3,8 +3,20 @@ import java.math.BigInteger; public class Constant { - public static final BigInteger FILL = new BigInteger("1"); - public static final BigInteger CANCEL = new BigInteger("2"); + public enum OrderAction { + FILL(BigInteger.ONE), + CANCEL(BigInteger.TWO); + + private final BigInteger value; + + OrderAction(BigInteger value) { + this.value = value; + } + + public BigInteger getValue() { + return value; + } + } // Generalized Connection Variables public final static String RECEIPTS = "receipts"; @@ -16,10 +28,7 @@ public class Constant { public final static String NETWORK_ID = "networkId"; public final static String PROTOCOL_FEE = "protocolFee"; public final static String FEE_HANDLER = "feeHandler"; - public final static String OWNER = "owner"; - public final static String NATIVE_ADDRESS = "nativeAddress"; - public final static String DEPOSIT = "deposit"; public final static String ORDERS = "orders"; public final static String FINISHED_ORDERS = "finishedOrders"; - public final static String PERMIT = "permit"; + } diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/SwapOrder.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/db/SwapOrderDb.java similarity index 81% rename from contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/SwapOrder.java rename to contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/db/SwapOrderDb.java index c94427eb..9e354a07 100644 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/SwapOrder.java +++ b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/db/SwapOrderDb.java @@ -1,13 +1,12 @@ -package network.icon.intent.structs; +package network.icon.intent.db; import java.math.BigInteger; - import score.ByteArrayObjectWriter; import score.Context; import score.ObjectReader; import score.ObjectWriter; -public class SwapOrder { +public class SwapOrderDb { public BigInteger id; // unique ID public String emitter;// Address of emitter contract public String srcNID; // Source Network ID @@ -20,7 +19,7 @@ public class SwapOrder { public BigInteger toAmount; // Minimum amount of the toToken to receive public byte[] data; // Additional data (if any) for future use (is this the right type?) - public SwapOrder(BigInteger id, String emitter, String srcNID, String dstNID, String creator, + public SwapOrderDb(BigInteger id, String emitter, String srcNID, String dstNID, String creator, String destinationAddress, String token, BigInteger amount, String toToken, BigInteger toAmount, byte[] data) { this.id = id; @@ -36,50 +35,27 @@ public SwapOrder(BigInteger id, String emitter, String srcNID, String dstNID, St this.data = data; } - private SwapOrder() { + private SwapOrderDb() { } - public static void writeObject(ObjectWriter writer, SwapOrder obj) { + public static void writeObject(ObjectWriter writer, SwapOrderDb obj) { obj.writeObject(writer); } - // add read object method - public static SwapOrder readObject(ObjectReader reader) { - SwapOrder obj = new SwapOrder(); + public static SwapOrderDb readObject(ObjectReader reader) { + SwapOrderDb obj = new SwapOrderDb(); reader.beginList(); - Context.println("reading swap order"); obj.id = reader.readBigInteger(); - Context.println(obj.id.toString()); obj.emitter = reader.readString(); - Context.println(obj.emitter.toString()); - obj.srcNID = reader.readString(); - Context.println(obj.srcNID.toString()); - obj.dstNID = reader.readString(); - Context.println(obj.dstNID.toString()); - obj.creator = reader.readString(); - Context.println(obj.creator.toString()); - obj.destinationAddress = reader.readString(); - Context.println(obj.destinationAddress.toString()); - obj.token = reader.readString(); - Context.println(obj.token.toString()); - obj.amount = reader.readBigInteger(); - Context.println(obj.amount.toString()); - obj.toToken = reader.readString(); - Context.println(obj.toToken.toString()); - obj.toAmount = reader.readBigInteger(); - Context.println(obj.toAmount.toString()); - obj.data = reader.readByteArray(); - Context.println(obj.data.toString()); - reader.end(); return obj; } @@ -102,12 +78,21 @@ public void writeObject(ObjectWriter writer) { public byte[] toBytes() { ByteArrayObjectWriter writer = Context.newByteArrayObjectWriter("RLPn"); - SwapOrder.writeObject(writer, this); + SwapOrderDb.writeObject(writer, this); return writer.toByteArray(); } - public static SwapOrder fromBytes(byte[] bytes) { + public static SwapOrderDb fromBytes(byte[] bytes) { + ObjectReader reader = Context.newByteArrayObjectReader("RLPn", bytes); + return readObject(reader); + } + + public SwapOrderDb fromBytesAndProperties(byte[] bytes, String token, BigInteger amount) { ObjectReader reader = Context.newByteArrayObjectReader("RLPn", bytes); + this.token = token; + this.amount = amount; + this.emitter = Context.getAddress().toString(); + this.creator = Context.getCaller().toString(); return readObject(reader); } diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/Cancel.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/Cancel.java deleted file mode 100644 index 111c374a..00000000 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/Cancel.java +++ /dev/null @@ -1,43 +0,0 @@ -package network.icon.intent.structs; - -import score.ByteArrayObjectWriter; -import score.Context; -import score.ObjectReader; -import score.ObjectWriter; - -public class Cancel { - public byte[] orderBytes; - - public Cancel() { - } - - public static void writeObject(ObjectWriter writer, Cancel obj) { - obj.writeObject(writer); - } - - public void writeObject(ObjectWriter writer) { - writer.beginList(1); - writer.write(this.orderBytes); - writer.end(); - } - - public static Cancel readObject(ObjectReader reader) { - Cancel obj = new Cancel(); - reader.beginList(); - obj.orderBytes = reader.readByteArray(); - reader.end(); - return obj; - } - - public static Cancel fromBytes(byte[] bytes) { - ObjectReader reader = Context.newByteArrayObjectReader("RLPn", bytes); - return readObject(reader); - } - - public byte[] toBytes() { - ByteArrayObjectWriter writer = Context.newByteArrayObjectWriter("RLPn"); - Cancel.writeObject(writer, this); - return writer.toByteArray(); - } - -} diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/TokenFallbackData.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/TokenFallbackData.java new file mode 100644 index 00000000..02e06e7b --- /dev/null +++ b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/structs/TokenFallbackData.java @@ -0,0 +1,79 @@ +package network.icon.intent.structs; + +import score.Address; +import score.ByteArrayObjectWriter; +import score.Context; +import score.ObjectReader; +import score.ObjectWriter; + +public class TokenFallbackData { + public byte[] swapOrderData; + public String type; + public Address solver; + + public TokenFallbackData(byte[] _swapOrderData, String _type, Address _solver) { + this.swapOrderData = _swapOrderData; + this.type = _type; + this.solver = _solver; + } + + private TokenFallbackData() { + } + + public static void writeObject(ObjectWriter writer, TokenFallbackData obj) { + obj.writeObject(writer); + } + + public void writeObject(ObjectWriter writer) { + writer.beginList(3); + writer.write(this.swapOrderData); + writer.write(this.type); + writer.write(this.solver); + writer.end(); + } + + public static TokenFallbackData readObject(ObjectReader reader) { + TokenFallbackData obj = new TokenFallbackData(); + reader.beginList(); + obj.swapOrderData = reader.readByteArray(); + obj.type = reader.readString(); + obj.solver = reader.readAddress(); + reader.end(); + return obj; + } + + public byte[] toBytes() { + ByteArrayObjectWriter writer = Context.newByteArrayObjectWriter("RLPn"); + TokenFallbackData.writeObject(writer, this); + return writer.toByteArray(); + } + + public static TokenFallbackData fromBytes(byte[] bytes) { + ObjectReader reader = Context.newByteArrayObjectReader("RLPn", bytes); + return readObject(reader); + } + + public byte[] getSwapOrder() { + return swapOrderData; + } + + public void setSwapOrder(byte[] _swapOrderData) { + this.swapOrderData = _swapOrderData; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public Address getSolver() { + return solver; + } + + public void setSolver(Address solver) { + this.solver = solver; + } +} diff --git a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/utils/SwapOrderData.java b/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/utils/SwapOrderData.java deleted file mode 100644 index 8c9c6297..00000000 --- a/contracts/javascore/Intent_Contracts/app/src/main/java/network/icon/intent/utils/SwapOrderData.java +++ /dev/null @@ -1,17 +0,0 @@ -package network.icon.intent.utils; - -import java.math.BigInteger; - -public class SwapOrderData { - public BigInteger id; - public String emitter; - public String srcNID; - public String dstNID; - public String creator; - public String destinationAddress; - public String token; - public BigInteger amount; - public String toToken; - public BigInteger toAmount; - public byte[] data; -} diff --git a/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/EncodingsTest.java b/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/EncodingsTest.java index a83a7f88..987a3cb4 100644 --- a/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/EncodingsTest.java +++ b/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/EncodingsTest.java @@ -3,118 +3,124 @@ import java.math.BigInteger; import java.util.Arrays; -import network.icon.intent.structs.Cancel; import org.junit.jupiter.api.Test; import com.iconloop.score.test.TestBase; +import score.Context; -import network.icon.intent.constants.Constant; +import network.icon.intent.constants.Constant.OrderAction; +import network.icon.intent.db.SwapOrderDb; import network.icon.intent.structs.OrderFill; import network.icon.intent.structs.OrderMessage; -import network.icon.intent.structs.SwapOrder; +import score.ByteArrayObjectWriter; import static org.junit.jupiter.api.Assertions.*; public class EncodingsTest extends TestBase { - public static byte[] hexStringToByteArray(String hexString) { - int length = hexString.length(); - byte[] byteArray = new byte[length / 2]; + @Test + void testSwapOrder() { + + BigInteger id = BigInteger.valueOf(1); + String emitter = "0xbe6452d4d6c61cee97d3"; + String srcNID = "Ethereum"; + String dstNID = "Polygon"; + String creator = "0x3e36eddd65e239222e7e67"; + String destinationAddress = "0xd2c6218b875457a41b6fb7964e"; + String token = "0x14355340e857912188b7f202d550222487"; + BigInteger amount = BigInteger.valueOf(1000); + String toToken = "0x91a4728b517484f0f610de7b"; + BigInteger toAmount = BigInteger.valueOf(900); + byte[] data = "".getBytes(); + + SwapOrderDb swapOrder1 = new SwapOrderDb(id, emitter, srcNID, dstNID, creator, destinationAddress, + token, + amount, + toToken, toAmount, data); + + byte[] expectedBytes = hexStringToByteArray( + "f8a601963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a43078313433353533343065383537393132313838623766323032643535303232323438378203e89a307839316134373238623531373438346630663631306465376282038480"); + + assertTrue(Arrays.equals(expectedBytes, swapOrder1.toBytes())); + + SwapOrderDb order2 = new SwapOrderDb( + BigInteger.valueOf(1), + "0xbe6452d4d6c61cee97d3", + "Ethereum", + "Polygon", + "0x3e36eddd65e239222e7e67", + "0xd2c6218b875457a41b6fb7964e", + "0x14355340e857912188b7f202d550222487", + BigInteger.valueOf(100000).pow(22), + "0x91a4728b517484f0f610de7b", + BigInteger.valueOf(900).pow(7), + "hello1".getBytes()); + String expectedBytes2 = "f8df01963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a4307831343335353334306538353739313231383862376632303264353530323232343837ae2a94608f8d29fbb7af52d1bc1667f505440cc75cababdc5961bfcc9f54dadd1a40000000000000000000000000009a30783931613437323862353137343834663066363130646537628919edb3f06ca68840008668656c6c6f31"; + assertEquals(expectedBytes2.toUpperCase(), byteArrayToHex(order2.toBytes())); + } + + @Test + void testOrderMessage() { + OrderMessage orderMessage = new OrderMessage(OrderAction.FILL.getValue(), + hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a")); + + byte[] expectedBytes = hexStringToByteArray("d601946c449988e2f33302803c93f8287dc1d8cb33848a"); + assertArrayEquals(expectedBytes, orderMessage.toBytes()); + + OrderMessage cancelMessage = new OrderMessage(OrderAction.CANCEL.getValue(), + hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a")); + + expectedBytes = hexStringToByteArray("d602946c449988e2f33302803c93f8287dc1d8cb33848a"); + assertTrue(Arrays.equals(expectedBytes, cancelMessage.toBytes())); + } + + @Test + void testOrderFill() { + OrderFill orderFill = new OrderFill(BigInteger.valueOf(1), + hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a"), + "0xcb0a6bbccfccde6be9f10ae781b9d9b00d6e63"); + + byte[] expectedBytes = hexStringToByteArray( + "f83f01946c449988e2f33302803c93f8287dc1d8cb33848aa830786362306136626263636663636465366265396631306165373831623964396230306436653633"); + assertTrue(Arrays.equals(expectedBytes, orderFill.toBytes())); + + OrderFill orderFill2 = new OrderFill(BigInteger.valueOf(2), + hexStringToByteArray("cb0a6bbccfccde6be9f10ae781b9d9b00d6e63"), + "0x6c449988e2f33302803c93f8287dc1d8cb33848a"); + + expectedBytes = hexStringToByteArray( + "f8400293cb0a6bbccfccde6be9f10ae781b9d9b00d6e63aa307836633434393938386532663333333032383033633933663832383764633164386362333338343861"); + assertTrue(Arrays.equals(expectedBytes, orderFill2.toBytes())); + } + + @Test + void testOrderCancel() { + byte[] orderBytes = hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a"); + byte[] expectedBytes = hexStringToByteArray("d5946c449988e2f33302803c93f8287dc1d8cb33848a"); + ByteArrayObjectWriter writer = Context.newByteArrayObjectWriter("RLPn"); + writer.beginList(1); + writer.write(orderBytes); + writer.end(); + byte[] serializedBytes = writer.toByteArray(); + assertTrue(Arrays.equals(expectedBytes, serializedBytes)); + } + + public static byte[] hexStringToByteArray(String hexString) { + int length = hexString.length(); + byte[] byteArray = new byte[length / 2]; - for (int i = 0; i < length; i += 2) { - byteArray[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) - + Character.digit(hexString.charAt(i + 1), 16)); + for (int i = 0; i < length; i += 2) { + byteArray[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + + Character.digit(hexString.charAt(i + 1), 16)); + } + return byteArray; } - return byteArray; - } - public static String byteArrayToHex(byte[] byteArray) { - StringBuilder hexString = new StringBuilder(); - for (byte b : byteArray) { - hexString.append(String.format("%02X", b)); + public static String byteArrayToHex(byte[] byteArray) { + StringBuilder hexString = new StringBuilder(); + for (byte b : byteArray) { + hexString.append(String.format("%02X", b)); + } + return hexString.toString(); } - return hexString.toString(); - } - - @Test - void testSwapOrder() { - - BigInteger id = BigInteger.valueOf(1); - String emitter = "0xbe6452d4d6c61cee97d3"; - String srcNID = "Ethereum"; - String dstNID = "Polygon"; - String creator = "0x3e36eddd65e239222e7e67"; - String destinationAddress = "0xd2c6218b875457a41b6fb7964e"; - String token = "0x14355340e857912188b7f202d550222487"; - BigInteger amount = BigInteger.valueOf(1000); - String toToken = "0x91a4728b517484f0f610de7b"; - BigInteger toAmount = BigInteger.valueOf(900); - String data = ""; - - SwapOrder swapOrder1 = new SwapOrder(id, emitter, srcNID, dstNID, creator, destinationAddress, token, amount, - toToken, toAmount, data); - - byte[] expectedBytes = hexStringToByteArray( - "f8a601963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a43078313433353533343065383537393132313838623766323032643535303232323438378203e89a307839316134373238623531373438346630663631306465376282038480"); - - assertTrue(Arrays.equals(expectedBytes, swapOrder1.toBytes())); - - SwapOrder order2 = new SwapOrder( - BigInteger.valueOf(1), - "0xbe6452d4d6c61cee97d3", - "Ethereum", - "Polygon", - "0x3e36eddd65e239222e7e67", - "0xd2c6218b875457a41b6fb7964e", - "0x14355340e857912188b7f202d550222487", - BigInteger.valueOf(100000).pow(22), - "0x91a4728b517484f0f610de7b", - BigInteger.valueOf(900).pow(7), - "hello1"); - String expectedBytes2 = "f8df01963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a4307831343335353334306538353739313231383862376632303264353530323232343837ae2a94608f8d29fbb7af52d1bc1667f505440cc75cababdc5961bfcc9f54dadd1a40000000000000000000000000009a30783931613437323862353137343834663066363130646537628919edb3f06ca68840008668656c6c6f31"; - assertEquals(expectedBytes2.toUpperCase(), byteArrayToHex(order2.toBytes())); - } - - @Test - void testOrderMessage() { - OrderMessage orderMessage = new OrderMessage(Constant.FILL, - hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a")); - - byte[] expectedBytes = hexStringToByteArray("d601946c449988e2f33302803c93f8287dc1d8cb33848a"); - assertArrayEquals(expectedBytes, orderMessage.toBytes()); - - OrderMessage cancelMessage = new OrderMessage(Constant.CANCEL, - hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a")); - - expectedBytes = hexStringToByteArray("d602946c449988e2f33302803c93f8287dc1d8cb33848a"); - assertTrue(Arrays.equals(expectedBytes, cancelMessage.toBytes())); - } - - @Test - void testOrderFill() { - OrderFill orderFill = new OrderFill(BigInteger.valueOf(1), - hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a"), - "0xcb0a6bbccfccde6be9f10ae781b9d9b00d6e63"); - - byte[] expectedBytes = hexStringToByteArray( - "f83f01946c449988e2f33302803c93f8287dc1d8cb33848aa830786362306136626263636663636465366265396631306165373831623964396230306436653633"); - assertTrue(Arrays.equals(expectedBytes, orderFill.toBytes())); - - OrderFill orderFill2 = new OrderFill(BigInteger.valueOf(2), - hexStringToByteArray("cb0a6bbccfccde6be9f10ae781b9d9b00d6e63"), - "0x6c449988e2f33302803c93f8287dc1d8cb33848a"); - - expectedBytes = hexStringToByteArray( - "f8400293cb0a6bbccfccde6be9f10ae781b9d9b00d6e63aa307836633434393938386532663333333032383033633933663832383764633164386362333338343861"); - assertTrue(Arrays.equals(expectedBytes, orderFill2.toBytes())); - } - - @Test - void testOrderCancel() { - Cancel cancel = new Cancel(); - cancel.orderBytes = hexStringToByteArray("6c449988e2f33302803c93f8287dc1d8cb33848a"); - - byte[] expectedBytes = hexStringToByteArray("d5946c449988e2f33302803c93f8287dc1d8cb33848a"); - assertTrue(Arrays.equals(expectedBytes, cancel.toBytes())); - } } diff --git a/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/IntentTest.java b/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/IntentTest.java index ffc93673..7735e73a 100644 --- a/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/IntentTest.java +++ b/contracts/javascore/Intent_Contracts/app/src/test/java/intent_contracts/IntentTest.java @@ -7,23 +7,20 @@ import intent_contracts.mocks.MockToken; import network.icon.intent.Intent; -import network.icon.intent.constants.Constant; -import network.icon.intent.structs.Cancel; +import network.icon.intent.constants.Constant.OrderAction; import network.icon.intent.structs.OrderFill; import network.icon.intent.structs.OrderMessage; -import network.icon.intent.structs.SwapOrder; -import network.icon.intent.utils.SwapOrderData; -import score.Context; +import network.icon.intent.structs.TokenFallbackData; +import network.icon.intent.db.SwapOrderDb; -import com.eclipsesource.json.Json; -import com.eclipsesource.json.JsonObject; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + import score.UserRevertedException; +import score.Context; import java.math.BigInteger; -import java.nio.charset.StandardCharsets; - import static java.math.BigInteger.TEN; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -31,1011 +28,638 @@ import static org.mockito.Mockito.when; public class IntentTest extends TestBase { -private static final ServiceManager sm = getServiceManager(); -private static final Account deployer = sm.createAccount(); -private static final Account feeHandler = sm.createAccount(); -private static final Account relayAddress = sm.createAccount(); -private static final Account user1 = sm.createAccount(); -private static final Account user2 = sm.createAccount(); -private static final Account solver = sm.createAccount(); - -private static Score intent; -private MockToken token; - -private final BigInteger protocolFee = BigInteger.valueOf(50); -private static final BigInteger initialSupply = BigInteger.valueOf(1000); -private static final BigInteger totalSupply = -initialSupply.multiply(TEN.pow(18)); - -// swapOrderData -public final BigInteger id = BigInteger.ONE; -public String emitter; -public String srcNID = "Network-1"; -public String dstNID = "Network-2"; -public String creator; -public String destinationAddress; -public String swapToken; -public BigInteger amount = BigInteger.valueOf(500).multiply(TEN.pow(18)); -public String toToken = "0x7891"; -public BigInteger toAmount = BigInteger.valueOf(500).multiply(TEN.pow(18)); -public String data = ""; - -@BeforeEach -void setup() throws Exception { -// Deploy a mock token contract -token = new MockToken(sm, deployer); - -// Deploy Intent contract with correct parameters -intent = sm.deploy(deployer, Intent.class, "Network-1", protocolFee, -feeHandler.getAddress(), -relayAddress.getAddress()); -} - -@Test -void testSwap() { -// Set mock behavior for the initial balances -when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); -when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); -when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - -// Assert deployer has total supply initially -assertEquals(totalSupply, -token.tokenContract.mock.balanceOf(deployer.getAddress())); - -// Simulate transfer from deployer to user1 -boolean success = token.tokenContract.mock.transfer(user1.getAddress(), -totalSupply); -assertTrue(success); - -// Assert user1 now has the total supply -when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); -assertEquals(totalSupply, -token.tokenContract.mock.balanceOf(user1.getAddress())); - -when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); -assertEquals(BigInteger.ZERO, -token.tokenContract.mock.balanceOf(deployer.getAddress())); - -// Create SwapOrderData and set the required parameters -creator = user1.getAddress().toString(); -swapToken = token.tokenContract.getAddress().toString(); -emitter = intent.getAddress().toString(); -destinationAddress = user2.getAddress().toString(); -SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, -dstNID, creator, destinationAddress, -swapToken, amount, toToken, toAmount, data); - -String depositor = user1.getAddress().toString(); -byte[] swapOrderDataBytes = swapOrder.toBytes(); - -JsonObject json = new JsonObject(); - -// JSONObject jsonObject = new JSONObject(); -json.set("depositor", depositor); -json.set("token", token.tokenContract.getAddress().toString()); -json.set("amount", amount.toString()); -json.set("swapOrderDataBytes", -bytesToHex(swapOrderDataBytes)); - -byte[] finalData = jsonObjectToByteArray(json); -intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, -finalData); - -// // Simulate token balance changes post-swap -when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply.subtract(amount)); -when(token.tokenContract.mock.balanceOf(intent.getAddress())).thenReturn(amount); - -// Assert the balances after the swap -assertEquals(totalSupply.subtract(amount), -token.tokenContract.mock.balanceOf(user1.getAddress())); -assertEquals(amount, -token.tokenContract.mock.balanceOf(intent.getAddress())); -} - - @Test - void testSwapInvalidCreator() { - - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - - creator = intent.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); // This should revert - }); - - assertEquals("Reverted(0): Creator must be sender", - exception.getMessage()); - } - - @Test - void testSwapInvalidSrcNid() { - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - srcNID = "dummy"; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - }); - - assertEquals("Reverted(0): NID is misconfigured", - exception.getMessage()); - } - - @Test - void testSwapInvalidEmitter() { - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = user1.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - }); - - assertEquals("Reverted(0): Emitter specified is not this", - exception.getMessage()); - } - - @Test - void testFillOrder() { - - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - // // - // - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - // // - // - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); - - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - - - - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - - token.tokenContract.mock.approve(intent.getAddress(), amount); - - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); - - // Create SwapOrderData and set the required parameters - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; - - OrderFill orderFill = new OrderFill(swapOrder.id, - swapOrder.toBytes(), - solver.getAddress().toString()); - OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), - orderFill.toBytes()); - - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); - } - - @Test - void testFillOrderAlreadyFilled() { - - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - - - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); - - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - - + private static final ServiceManager sm = getServiceManager(); + private static final Account deployer = sm.createAccount(); + private static final Account feeHandler = sm.createAccount(); + private static final Account relayAddress = sm.createAccount(); + private static final Account user1 = sm.createAccount(); + private static final Account user2 = sm.createAccount(); + private static final Account solver = sm.createAccount(); + + private static Score intent; + private MockToken token; + + private final BigInteger protocolFee = BigInteger.valueOf(50); + private static final BigInteger initialSupply = BigInteger.valueOf(1000); + private static final BigInteger totalSupply = initialSupply.multiply(TEN.pow(18)); + + // swapOrderData + public final BigInteger id = BigInteger.ONE; + public String emitter; + public String srcNID = "Network-1"; + public String dstNID = "Network-2"; + public String creator; + public String destinationAddress; + public String swapToken; + public BigInteger amount = BigInteger.valueOf(500).multiply(TEN.pow(18)); + public String toToken = "0x7891"; + public BigInteger toAmount = BigInteger.valueOf(500).multiply(TEN.pow(18)); + public byte[] data = "".getBytes(); + + @BeforeEach + void setup() throws Exception { + // Deploy a mock token contract + token = new MockToken(sm, deployer); + + // Deploy Intent contract with correct parameters + intent = sm.deploy(deployer, Intent.class, "Network-1", protocolFee, + feeHandler.getAddress(), + relayAddress.getAddress()); + } + + @Test + void testSwap() { + // Set mock behavior for the initial balances + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + + // Assert deployer has total supply initially + assertEquals(totalSupply, token.tokenContract.mock.balanceOf(deployer.getAddress())); + + // Simulate transfer from deployer to user1 + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), totalSupply); + assertTrue(success); + + // Assert user1 now has the total supply + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, token.tokenContract.mock.balanceOf(user1.getAddress())); + + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, token.tokenContract.mock.balanceOf(deployer.getAddress())); + + // Create SwapOrderData and set the required parameters + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); + + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + + // Spy on the intent contract to verify event emissions + Intent intentSpy = Mockito.spy((Intent) intent.getInstance()); + intent.setInstance(intentSpy); + + // Invoke the tokenFallback method + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, fallbackData.toBytes()); + + // Verify the event SwapIntent was emitted with the correct parameters + Mockito.verify(intentSpy).SwapIntent( + Mockito.eq(id), + Mockito.eq(emitter), + Mockito.eq(srcNID), + Mockito.eq(dstNID), + Mockito.eq(creator), + Mockito.eq(destinationAddress), + Mockito.eq(swapToken), + Mockito.eq(amount), + Mockito.eq(toToken), + Mockito.eq(toAmount), + Mockito.eq(data)); + + // Simulate token balance changes post-swap + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply.subtract(amount)); + when(token.tokenContract.mock.balanceOf(intent.getAddress())).thenReturn(amount); + + // Assert the balances after the swap + assertEquals(totalSupply.subtract(amount), token.tokenContract.mock.balanceOf(user1.getAddress())); + assertEquals(amount, token.tokenContract.mock.balanceOf(intent.getAddress())); + } + + @Test + void testSwapInvalidCreator() { + + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + + creator = intent.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); + + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); // This should revert + }); + + assertEquals("Reverted(0): Depositer must be creator", + exception.getMessage()); + } + + @Test + void testSwapInvalidSrcNid() { + + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + srcNID = "dummy"; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); + + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + }); + + assertEquals("Reverted(0): NID is misconfigured", + exception.getMessage()); + } + + @Test + void testSwapInvalidEmitter() { + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = user1.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); + + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + }); + + assertEquals("Reverted(0): Emitter specified is not this", + exception.getMessage()); + } + + @Test + void testFillOrder() { + + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); + + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); + + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); + + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "fill", user1.getAddress()); + + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + } - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); + @Test + void testFillOrderAlreadyFilled() { + + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - token.tokenContract.mock.approve(intent.getAddress(), amount); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - OrderFill orderFill = new OrderFill(swapOrder.id, - swapOrder.toBytes(), - solver.getAddress().toString()); - OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), - orderFill.toBytes()); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - // Create SwapOrderData and set the required parameters - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); - }); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - assertEquals("Reverted(0): Order has already been filled", - exception.getMessage()); - } + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "fill", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); - @Test - void testFillOrderSameChain() { + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + }); + assertEquals("Reverted(0): Order has already been filled", + exception.getMessage()); + } - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + @Test + void testFillOrderSameChain() { + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + dstNID = srcNID; + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + token.tokenContract.mock.approve(intent.getAddress(), amount); - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - dstNID = srcNID; - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); + when(token.tokenContract.mock.allowance(user1.getAddress(), + intent.getAddress())).thenReturn(amount); - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); + OrderFill orderFill = new OrderFill(swapOrder.id, + swapOrder.toBytes(), + solver.getAddress().toString()); + OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), + orderFill.toBytes()); - JsonObject json = new JsonObject(); + TokenFallbackData fallbackData2 = new TokenFallbackData(swapOrder.toBytes(), "fill", + solver.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData2.toBytes()); + } - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); + @Test + void testCancelOrder() { - byte[] finalData = jsonObjectToByteArray(json); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - token.tokenContract.mock.approve(intent.getAddress(), amount); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); -// SwapOrder swapOrder = new SwapOrder( -// swapOrderData.id, swapOrderData.emitter, swapOrderData.srcNID, -// swapOrderData.dstNID, swapOrderData.creator, -// swapOrderData.destinationAddress, -// swapOrderData.token, swapOrderData.amount, swapOrderData.toToken, -// swapOrderData.toAmount, swapOrderData.data); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - OrderFill orderFill = new OrderFill(swapOrder.id, - swapOrder.toBytes(), - solver.getAddress().toString()); - OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), - orderFill.toBytes()); + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); - // Create SwapOrderData and set the required parameters - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; + BigInteger beforeCancelConn = (BigInteger) intent.call("getConnSn"); - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); - } + intent.invoke(user1, "cancel", swapOrder.id); - @Test - void testCancelOrder() { + BigInteger afterCancelConn = (BigInteger) intent.call("getConnSn"); + assertEquals(beforeCancelConn, + afterCancelConn.subtract(BigInteger.valueOf(1))); + } - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + @Test + void testCancelOrderOnlyCreator() { + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(deployer, "cancel", swapOrder.id); + }); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + assertEquals("Reverted(0): Only creator can cancel this order", + exception.getMessage()); + } - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); + @Test + void testResolveOrder() { - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - JsonObject json = new JsonObject(); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - byte[] finalData = jsonObjectToByteArray(json); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - BigInteger beforeCancelConn = (BigInteger) intent.call("getConnSn"); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); - intent.invoke(user1, "cancel", swapOrder.id); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - BigInteger afterCancelConn = (BigInteger) intent.call("getConnSn"); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - assertEquals(beforeCancelConn, - afterCancelConn.subtract(BigInteger.valueOf(1))); - } + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); - @Test - void testCancelOrderOnlyCreator() { + when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); + token.tokenContract.mock.approve(intent.getAddress(), amount); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + when(token.tokenContract.mock.allowance(user1.getAddress(), + intent.getAddress())).thenReturn(amount); + OrderFill orderFill = new OrderFill(swapOrder.id, swapOrder.toBytes(), + solver.getAddress().toString()); + OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), + orderFill.toBytes()); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + TokenFallbackData fallbackData2 = new TokenFallbackData(swapOrder.toBytes(), "fill", + solver.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData2.toBytes()); + intent.invoke(relayAddress, "recvMessage", dstNID, 1, + orderMessage.toBytes()); - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + BigInteger conn = (BigInteger) intent.call("getConnSn"); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + assertEquals(intent.call("getReceipt", dstNID, conn), true); + } - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); + @Test + void testResolveOrderMisMatch() { + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); - JsonObject json = new JsonObject(); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); - byte[] finalData = jsonObjectToByteArray(json); + when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); + token.tokenContract.mock.approve(intent.getAddress(), amount); - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(deployer, "cancel", swapOrder.id); - }); + when(token.tokenContract.mock.allowance(user1.getAddress(), + intent.getAddress())).thenReturn(amount); - assertEquals("Reverted(0): Only creator can cancel this order", - exception.getMessage()); - } + OrderFill orderFill = new OrderFill(swapOrder.id, swapOrder.toBytes(), + solver.getAddress().toString()); + OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), + orderFill.toBytes()); - @Test - void testResolveOrder() { + TokenFallbackData fallbackData2 = new TokenFallbackData(swapOrder.toBytes(), "fill", + solver.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData2.toBytes()); + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(relayAddress, "recvMessage", "dummy", 1, + orderMessage.toBytes()); + }); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); + assertEquals("Reverted(0): Invalid Network", exception.getMessage()); + } - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); + @Test + void testResolveCancel() { + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + boolean success = token.tokenContract.mock.transfer(user1.getAddress(), + totalSupply); + assertTrue(success); + when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); + assertEquals(totalSupply, + token.tokenContract.mock.balanceOf(user1.getAddress())); - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); + when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); + assertEquals(BigInteger.ZERO, + token.tokenContract.mock.balanceOf(deployer.getAddress())); + creator = user1.getAddress().toString(); + swapToken = token.tokenContract.getAddress().toString(); + emitter = intent.getAddress().toString(); + destinationAddress = user2.getAddress().toString(); + toToken = swapToken; + SwapOrderDb swapOrder = new SwapOrderDb(id, emitter, srcNID, + dstNID, creator, destinationAddress, + swapToken, amount, toToken, toAmount, data); - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); + TokenFallbackData fallbackData = new TokenFallbackData(swapOrder.toBytes(), "swap", user1.getAddress()); + intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, + fallbackData.toBytes()); - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); + when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); + token.tokenContract.mock.approve(intent.getAddress(), amount); - JsonObject json = new JsonObject(); + when(token.tokenContract.mock.allowance(user1.getAddress(), + intent.getAddress())).thenReturn(amount); - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); + OrderMessage orderMessage = new OrderMessage(OrderAction.CANCEL.getValue(), + swapOrder.toBytes()); - byte[] finalData = jsonObjectToByteArray(json); + OrderFill orderFill = new OrderFill(swapOrder.id, + swapOrder.toBytes(), + swapOrder.creator); - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); + OrderMessage fillMessage = new OrderMessage(OrderAction.FILL.getValue(), + orderFill.toBytes()); + intent.invoke(relayAddress, "recvMessage", srcNID, 1, + orderMessage.toBytes()); + boolean isFinished = (boolean) intent.call("getFinishedorders", + Context.hash("keccak-256", swapOrder.toBytes())); + assertTrue(isFinished); + } - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); + @Test + void testSetFeeHandler() { + Account feeHandler = sm.createAccount(); + intent.invoke(deployer, "setFeeHandler", feeHandler.getAddress()); - token.tokenContract.mock.approve(intent.getAddress(), amount); + assertEquals(feeHandler.getAddress(), intent.call("getFeeHandler")); + } - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); + @Test + void testSetFeeHandlerNonAdmin() { + Account feeHandler = sm.createAccount(); - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "setFeeHandler", feeHandler.getAddress()); + }); - OrderFill orderFill = new OrderFill(swapOrder.id, swapOrder.toBytes(), - solver.getAddress().toString()); - OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), - orderFill.toBytes()); + assertEquals("Reverted(0): Not Owner", exception.getMessage()); + } - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); + @Test + void testSetProtocol() { + intent.invoke(deployer, "setProtocolFee", TEN); - intent.invoke(relayAddress, "recvMessage", dstNID, 1, - orderMessage.toBytes()); + assertEquals(TEN, intent.call("getProtocolFee")); + } - BigInteger conn = (BigInteger) intent.call("getConnSn"); + @Test + void testSetProtocolFeeNonAdmin() { - assertEquals(intent.call("getReceipt", dstNID, conn), true); - } + UserRevertedException exception = assertThrows(UserRevertedException.class, + () -> { + intent.invoke(user1, "setProtocolFee", TEN); + }); - @Test - void testResolveOrderMisMatch() { - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - - - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); - - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - - - - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - - token.tokenContract.mock.approve(intent.getAddress(), amount); - - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); - - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; - - OrderFill orderFill = new OrderFill(swapOrder.id, swapOrder.toBytes(), - solver.getAddress().toString()); - OrderMessage orderMessage = new OrderMessage(BigInteger.valueOf(1), - orderFill.toBytes()); - - intent.invoke(user1, "fill", swapOrderData, - solver.getAddress().toString()); - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(relayAddress, "recvMessage", "dummy", 1, - orderMessage.toBytes()); - }); - - assertEquals("Reverted(0): Invalid Network", exception.getMessage()); - - } - - @Test - void testResolveCancel() { - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(totalSupply); - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(BigInteger.ZERO); - - - when(token.tokenContract.mock.balanceOf(user2.getAddress())).thenReturn(BigInteger.ZERO); - - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - boolean success = token.tokenContract.mock.transfer(user1.getAddress(), - totalSupply); - assertTrue(success); - - - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - assertEquals(totalSupply, - token.tokenContract.mock.balanceOf(user1.getAddress())); - - - when(token.tokenContract.mock.balanceOf(deployer.getAddress())).thenReturn(BigInteger.ZERO); - assertEquals(BigInteger.ZERO, - token.tokenContract.mock.balanceOf(deployer.getAddress())); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - - intent.invoke(user1, "tokenFallback", user1.getAddress(), amount, - finalData); - - - - when(token.tokenContract.mock.balanceOf(solver.getAddress())).thenReturn(totalSupply); - - token.tokenContract.mock.approve(intent.getAddress(), amount); - - when(token.tokenContract.mock.allowance(user1.getAddress(), - intent.getAddress())).thenReturn(amount); - - SwapOrderData swapOrderData = new SwapOrderData(); - swapOrderData.id = swapOrder.id; - swapOrderData.emitter = swapOrder.emitter; - swapOrderData.srcNID = swapOrder.srcNID; - swapOrderData.dstNID = swapOrder.dstNID; - swapOrderData.creator = swapOrder.creator; - swapOrderData.destinationAddress = swapOrder.destinationAddress; - swapOrderData.token = swapOrder.token; - swapOrderData.amount = swapOrder.amount; - swapOrderData.toToken = swapOrder.toToken; - swapOrderData.toAmount = swapOrder.toAmount; - swapOrderData.data = swapOrder.data; - - Cancel cancel = new Cancel(); - cancel.orderBytes = swapOrder.toBytes(); - - OrderMessage orderMessage = new OrderMessage(Constant.CANCEL, - cancel.toBytes()); - - OrderFill orderFill = new OrderFill(swapOrder.id, - swapOrder.toBytes(), - swapOrder.creator); - - OrderMessage fillMessage = new OrderMessage(Constant.FILL, - orderFill.toBytes()); - - intent.invoke(relayAddress, "recvMessage", srcNID, 1, - orderMessage.toBytes()); - - boolean isFinished = (boolean) intent.call("getFinishedorders", - Context.hash("keccak-256", swapOrder.toBytes())); - assertTrue(isFinished); - } - - @Test - void testSetFeeHandler() { - Account feeHandler = sm.createAccount(); - intent.invoke(deployer, "setFeeHandler", feeHandler.getAddress()); - - assertEquals(feeHandler.getAddress(), intent.call("getFeeHandler")); - } - - @Test - void testSetFeeHandlerNonAdmin() { - Account feeHandler = sm.createAccount(); - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "setFeeHandler", feeHandler.getAddress()); - }); - - assertEquals("Reverted(0): Not Owner", exception.getMessage()); - } - - @Test - void testSetProtocol() { - intent.invoke(deployer, "setProtocolFee", TEN); - - assertEquals(TEN, intent.call("getProtocolFee")); - } - - @Test - void testSetProtocolFeeNonAdmin() { - - UserRevertedException exception = - assertThrows(UserRevertedException.class, - () -> { - intent.invoke(user1, "setProtocolFee", TEN); - }); - - assertEquals("Reverted(0): Not Owner", exception.getMessage()); - } - - @Test - public void testTokenFallback() { - - when(token.tokenContract.mock.balanceOf(user1.getAddress())).thenReturn(totalSupply); - - BigInteger depositedAmount0 = (BigInteger) intent.call("getDepositAmount", - user1.getAddress().toString(), - token.tokenContract.getAddress().toString()); - assertEquals(BigInteger.ZERO, depositedAmount0); - - creator = user1.getAddress().toString(); - swapToken = token.tokenContract.getAddress().toString(); - emitter = intent.getAddress().toString(); - destinationAddress = user2.getAddress().toString(); - toToken = swapToken; - SwapOrder swapOrder = new SwapOrder(id, emitter, srcNID, - dstNID, creator, destinationAddress, - swapToken, amount, toToken, toAmount, data); - - String depositor = user1.getAddress().toString(); - byte[] swapOrderDataBytes = swapOrder.toBytes(); - - JsonObject json = new JsonObject(); - - json.set("depositor", depositor); - json.set("token", token.tokenContract.getAddress().toString()); - json.set("amount", amount.toString()); - json.set("swapOrderDataBytes", - bytesToHex(swapOrderDataBytes)); - - byte[] finalData = jsonObjectToByteArray(json); - intent.invoke(user1, "tokenFallback", user1.getAddress(), - swapOrder.getAmount(), - finalData); - - BigInteger depositedAmount = (BigInteger) intent.call("getDepositAmount", - user1.getAddress().toString(), - token.tokenContract.getAddress().toString()); - assertEquals(amount, depositedAmount); - } - -public static String bytesToHex(byte[] bytes) { -StringBuilder hexString = new StringBuilder(2 * bytes.length); -for (byte b : bytes) { -String hex = Integer.toHexString(0xff & b); -if (hex.length() == 1) { -hexString.append('0'); -} -hexString.append(hex); -} -return hexString.toString(); -} - -public static byte[] jsonObjectToByteArray(JsonObject json) { -String jsonString = json.toString(); -return jsonString.getBytes(StandardCharsets.UTF_8); -} + assertEquals("Reverted(0): Not Owner", exception.getMessage()); + } }