From 76e6717f74083e6700edcd46455588d74f7077f4 Mon Sep 17 00:00:00 2001 From: gosticks Date: Mon, 8 Jan 2018 04:23:43 +0100 Subject: [PATCH] continued dev --- src/main/java/Bundle.java | 4 + src/main/java/Helpers.java | 26 +++++-- src/main/java/IotaFlashBridge.java | 114 +++++++++++++++++++++++++---- src/main/java/MultisigAddress.java | 2 +- src/main/java/Transaction.java | 38 ++++++++-- src/main/java/UserObject.java | 2 +- 6 files changed, 156 insertions(+), 30 deletions(-) diff --git a/src/main/java/Bundle.java b/src/main/java/Bundle.java index 43cae9c..7387eec 100644 --- a/src/main/java/Bundle.java +++ b/src/main/java/Bundle.java @@ -1,3 +1,6 @@ +import com.eclipsesource.v8.V8; +import com.eclipsesource.v8.V8Array; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -23,6 +26,7 @@ class Bundle { public ArrayList getBundles() { return bundles; } + } diff --git a/src/main/java/Helpers.java b/src/main/java/Helpers.java index c5b52af..cbbcce8 100644 --- a/src/main/java/Helpers.java +++ b/src/main/java/Helpers.java @@ -1,8 +1,5 @@ import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; public class Helpers { public static ArrayList createTransaction(UserObject user, ArrayList transfers, boolean shouldClose) { @@ -13,12 +10,13 @@ public class Helpers { System.out.println("No more addresses in channel."); } - ArrayList newTransfers; + ArrayList newTransfers; if (shouldClose) { + newTransfers = new ArrayList<>(); // newTransfers = IotaFlashBridge.close(user.getFlash().getSettlementAddresses(), user.getFlash().deposits); } else { - List test = IotaFlashBridge.prepare( + newTransfers = IotaFlashBridge.prepare( user.getFlash().settlementAddresses, user.getFlash().deposits, user.getUserIndex(), @@ -26,6 +24,24 @@ public class Helpers { ); } + ArrayList bundles = IotaFlashBridge.compose( + user.getFlash().balance, + user.getFlash().deposits, + user.getFlash().outputs, + toUse.getAddress(), + user.getFlash().remainderAddress, + user.getFlash().transfers, + newTransfers, + shouldClose + ); + + + signTransaction(user, bundles); + return null; } + + public static Object signTransaction(UserObject user, ArrayList bundles) { + return IotaFlashBridge.sign(user.getFlash().root, user.getSeed(), bundles); + } } diff --git a/src/main/java/IotaFlashBridge.java b/src/main/java/IotaFlashBridge.java index 5a72b67..9cfbd05 100644 --- a/src/main/java/IotaFlashBridge.java +++ b/src/main/java/IotaFlashBridge.java @@ -2,13 +2,12 @@ import com.eclipsesource.v8.*; import com.eclipsesource.v8.utils.V8ObjectUtils; import com.sun.org.apache.xpath.internal.operations.Mult; -import javax.jws.Oneway; + import java.io.IOException; import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Paths; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; import java.util.Map; @@ -111,7 +110,7 @@ public class IotaFlashBridge { * @param transfers array of all transfers (value, address) pairs * @return */ - public static List prepare(ArrayList settlementAddresses, ArrayList deposits, int index, ArrayList transfers) { + public static ArrayList prepare(ArrayList settlementAddresses, ArrayList deposits, int index, ArrayList transfers) { V8Array settlementAddressesJS = V8ObjectUtils.toV8Array(engine, settlementAddresses); V8Array depositJS = V8ObjectUtils.toV8Array(engine, deposits); List transferObj = new ArrayList(); @@ -131,13 +130,19 @@ public class IotaFlashBridge { V8Array ret = transfer.executeArrayFunction("prepare", V8ObjectUtils.toV8Array(engine, params)); List transfersReturnJS = V8ObjectUtils.toList(ret); - for (Object b: transfersReturnJS) { - Map test = V8ObjectUtils.toMap((V8Object) b); + ArrayList returnTransfers = new ArrayList<>(); + for (Object b: transfersReturnJS) { + Map values = (Map) b; + String obsoleteTag = (String) values.get("obsoleteTag"); + String address = (String) values.get("address"); + Integer value = (Integer) values.get("value"); + + returnTransfers.add(new Transaction(address, value, "", "", 0)); } // Call js. - return transfersReturnJS; + return returnTransfers; } /** @@ -152,19 +157,33 @@ public class IotaFlashBridge { * @param close * @return */ - public static List compose(int balance, ArrayList deposits, ArrayList outputs, MultisigAddress root, String remainderAddress, ArrayList history, ArrayList transfers, boolean close) { + public static ArrayList compose(int balance, + List deposits, + List outputs, + MultisigAddress root, + MultisigAddress remainderAddress, + List history, + List transfers, + boolean close) { V8Array depositsJS = V8ObjectUtils.toV8Array(engine, deposits); // Outputs List outputsObj = new ArrayList(); - for (Transfer t: outputs) { + for (Bundle t: outputs) { outputsObj.add(t.toMap()); } V8Array outputsJS = V8ObjectUtils.toV8Array(engine, outputsObj); + V8Object rootJS = V8ObjectUtils.toV8Object(engine, root.toMap()); + V8Object remainderJS = V8ObjectUtils.toV8Object(engine, remainderAddress.toMap()); + List historyObj = new ArrayList(); + for (Bundle t: history) { + historyObj.add(t.toMap()); + } + V8Array historyJS = V8ObjectUtils.toV8Array(engine, historyObj); List transfersObj = new ArrayList(); - for (Transfer t: transfers) { + for (Transaction t: transfers) { transfersObj.add(t.toMap()); } V8Array transfersJS = V8ObjectUtils.toV8Array(engine, transfersObj); @@ -175,16 +194,70 @@ public class IotaFlashBridge { params.add(balance); params.add(depositsJS); params.add(outputsJS); - + params.add(rootJS); + params.add(remainderJS); + params.add(history); + params.add(transfersJS); // Call js function. V8Array ret = transfer.executeArrayFunction("compose", V8ObjectUtils.toV8Array(engine, params)); List transfersReturnJS = V8ObjectUtils.toList(ret); // Parse return as array of bundles + ArrayList returnBundles = new ArrayList(); + for (Object returnEntry: transfersReturnJS) { + ArrayList b = (ArrayList) returnEntry; + ArrayList returnedTransactions = new ArrayList<>(); - return transfersReturnJS; + for (Object parsedObjects: b) { + Map bundleData = (Map) parsedObjects; + String signatureMessageFragment = (String) bundleData.get("signatureMessageFragment"); + String bundle = (String) bundleData.get("bundle"); + String address = (String) bundleData.get("address"); + String attachmentTimestampLowerBound = (String) bundleData.get("attachmentTimestampLowerBound"); + String attachmentTimestampUpperBound = (String) bundleData.get("attachmentTimestampUpperBound"); + String trunkTransaction = (String) bundleData.get("trunkTransaction"); + String attachmentTimestamp = (String) bundleData.get("attachmentTimestamp"); + Integer timestamp = (Integer) bundleData.get("timestamp"); + String tag = (String) bundleData.get("tag"); + String branchTransaction = (String) bundleData.get("branchTransaction"); + String nonce = (String) bundleData.get("nonce"); + String obsoleteTag = (String) bundleData.get("obsoleteTag"); + + Integer currentIndex = (Integer) bundleData.get("currentIndex"); + Integer value = (Integer) bundleData.get("value"); + Integer lastIndex = (Integer) bundleData.get("lastIndex"); + + Transaction parsedTransaction = new Transaction( + address, + bundle, + value.intValue(), + obsoleteTag, + tag, + timestamp, + signatureMessageFragment, + trunkTransaction, + branchTransaction, + + attachmentTimestamp, + attachmentTimestampUpperBound, + attachmentTimestampLowerBound, + nonce + ); + + returnedTransactions.add(parsedTransaction); + + System.out.println("Created bundle transaction: " + parsedTransaction.toString()); + } + + Bundle bundle = new Bundle(returnedTransactions); + returnBundles.add(bundle); + } + + System.out.println("Created bundles: " + returnBundles.size()); + + return returnBundles; } /** @@ -200,18 +273,29 @@ public class IotaFlashBridge { List bundleTmp = new ArrayList(); for (Bundle b: bundles) { - bundleTmp.add(b.toMap()); + List transactions = new ArrayList(); + for (Transaction t: b.getBundles()) { + transactions.add(t.toMap()); + } + bundleTmp.add(transactions); } V8Array bundlesJS = V8ObjectUtils.toV8Array(engine, bundleTmp); // Create params. // Now put all params into JS ready array. - List params = new ArrayList(); + List params = new ArrayList<>(); params.add(rootJS); params.add(seed); - params.add(bundles); + params.add(bundlesJS); - V8Object signatures = transfer.executeObjectFunction("sign", V8ObjectUtils.toV8Array(engine, params)); + V8Array signatures = transfer.executeArrayFunction("sign", V8ObjectUtils.toV8Array(engine, params)); + + for (Object o: V8ObjectUtils.toList(signatures)) { + Map returnValues = (Map) o; + for (Map.Entry entry: returnValues.entrySet()) { + System.out.println(entry.getKey() + " : " + entry.getValue()); + } + } // TODO: add singature object. return signatures; diff --git a/src/main/java/MultisigAddress.java b/src/main/java/MultisigAddress.java index afa69f0..5647a34 100644 --- a/src/main/java/MultisigAddress.java +++ b/src/main/java/MultisigAddress.java @@ -100,7 +100,7 @@ class MultisigAddress { for (Bundle b: bundles) { bundleList.add(b.getBundles()); } - map.put("bundle", bundleList); + map.put("bundles", bundleList); return map; } diff --git a/src/main/java/Transaction.java b/src/main/java/Transaction.java index 9df2841..adca669 100644 --- a/src/main/java/Transaction.java +++ b/src/main/java/Transaction.java @@ -2,13 +2,14 @@ import java.util.HashMap; import java.util.Map; class Transaction { - private String timestamp; + private int timestamp; private String address; private int value; - private int obsoleteTag; - private int tag; + private String obsoleteTag; + private String tag; // Signature stuff + private String bundle = ""; private String signatureMessageFragment = ""; private String trunkTransaction = ""; private String branchTransaction = ""; @@ -20,7 +21,7 @@ class Transaction { private String nonce = ""; // Unsigned constructor - public Transaction(String address, int value, int obsoleteTag, int tag, String timestamp) { + public Transaction(String address, int value, String obsoleteTag, String tag, int timestamp) { this.address = address; this.value = value; this.obsoleteTag = obsoleteTag; @@ -30,17 +31,20 @@ class Transaction { // Signed constructor public Transaction(String address, + String bundle, int value, - int obsoleteTag, - int tag, - String timestamp, + String obsoleteTag, + String tag, + int timestamp, String signatureMessageFragment, String trunkTransaction, String branchTransaction, String attachmentTimestamp, String attachmentTimestampUpperBound, - String attachmentTimestampLowerBound + String attachmentTimestampLowerBound, + + String nonce ) { this.address = address; this.value = value; @@ -54,6 +58,8 @@ class Transaction { this.attachmentTimestamp = attachmentTimestamp; this.attachmentTimestampUpperBound = attachmentTimestampUpperBound; this.attachmentTimestampLowerBound = attachmentTimestampLowerBound; + + this.nonce = nonce; } public int getValue() { @@ -70,6 +76,22 @@ class Transaction { map.put("obsoleteTag", obsoleteTag); map.put("tag", tag); map.put("timestamp", timestamp); + map.put("signatureMessageFragment", signatureMessageFragment); + map.put("trunkTransaction", trunkTransaction); + map.put("branchTransaction", branchTransaction); + map.put("attachmentTimestamp", attachmentTimestamp); + map.put("attachmentTimestampLowerBound", attachmentTimestampLowerBound); + map.put("attachmentTimestampUpperBound", attachmentTimestampUpperBound); return map; } + + public String toString() { + Map mapObj = toMap(); + String value = "{"; + for (Map.Entry entry: mapObj.entrySet()) { + value += "'" + entry.getKey() + "':'" + entry.getValue().toString() + "', "; + } + value += "}"; + return value; + } } \ No newline at end of file diff --git a/src/main/java/UserObject.java b/src/main/java/UserObject.java index 4bc47b8..062ccb9 100644 --- a/src/main/java/UserObject.java +++ b/src/main/java/UserObject.java @@ -78,7 +78,7 @@ class FlashObject { MultisigAddress remainderAddress; ArrayList deposits; // Clone correctly ArrayList outputs = new ArrayList(); - ArrayList transfers = new ArrayList(); + ArrayList transfers = new ArrayList(); FlashObject(int signersCount, int balance, ArrayList deposits) { this.signersCount = signersCount;