diff --git a/iotaflashlibjswrapper.iml b/iotaflashlibjswrapper.iml index f2b5225..b793751 100644 --- a/iotaflashlibjswrapper.iml +++ b/iotaflashlibjswrapper.iml @@ -12,5 +12,6 @@ + \ No newline at end of file diff --git a/pom.xml b/pom.xml index 5f16704..b9968dc 100644 --- a/pom.xml +++ b/pom.xml @@ -8,12 +8,24 @@ iota.flash.lib.js.wrapper 1.0-SNAPSHOT + + + jitpack.io + https://jitpack.io + + + com.eclipsesource.j2v8 j2v8_macosx_x86_64 4.6.0 + + com.github.iotaledger + iota~lib~java + v0.9.10 + diff --git a/src/main/java/Bundle.java b/src/main/java/Bundle.java index 1eeef4f..43cae9c 100644 --- a/src/main/java/Bundle.java +++ b/src/main/java/Bundle.java @@ -4,21 +4,25 @@ import java.util.List; import java.util.Map; class Bundle { - private ArrayList bundles; + private ArrayList bundles; - public Bundle(ArrayList bundles) { + public Bundle(ArrayList bundles) { this.bundles = bundles; } public Map toMap() { Map map = new HashMap(); List bundleList = new ArrayList(); - for (Bundle b: bundles) { + for (Transaction b: bundles) { bundleList.add(b.toMap()); } map.put("bundles", bundleList); return map; } + + public ArrayList getBundles() { + return bundles; + } } diff --git a/src/main/java/Digest.java b/src/main/java/Digest.java index 3b4d57e..3896c8c 100644 --- a/src/main/java/Digest.java +++ b/src/main/java/Digest.java @@ -35,4 +35,5 @@ class Digest { map.put("security", getSecurity()); return map; } + } diff --git a/src/main/java/Helpers.java b/src/main/java/Helpers.java new file mode 100644 index 0000000..c5b52af --- /dev/null +++ b/src/main/java/Helpers.java @@ -0,0 +1,31 @@ +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) { + CreateTransactionHelperObject toUse = IotaFlashBridge.updateLeafToRoot(user.getFlash().root); + + if (toUse.getGenerate() != 0) { + // TODO: tell the server to gen new address. + System.out.println("No more addresses in channel."); + } + + ArrayList newTransfers; + + if (shouldClose) { + // newTransfers = IotaFlashBridge.close(user.getFlash().getSettlementAddresses(), user.getFlash().deposits); + } else { + List test = IotaFlashBridge.prepare( + user.getFlash().settlementAddresses, + user.getFlash().deposits, + user.getUserIndex(), + transfers + ); + } + + return null; + } +} diff --git a/src/main/java/IotaFlashBridge.java b/src/main/java/IotaFlashBridge.java index e484b41..5a72b67 100644 --- a/src/main/java/IotaFlashBridge.java +++ b/src/main/java/IotaFlashBridge.java @@ -12,28 +12,20 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -public class IotaFlashBridge implements IotaFlashInterface { - private String iotaLibPath; - private V8 engine; - private V8Object transfer; - private V8Object multisig; +public class IotaFlashBridge { + private static String iotaLibPath = "res/iota.flash.js"; + private static V8 engine; + private static V8Object transfer; + private static V8Object multisig; - /** - * - * @param path - * @throws IOException - */ - IotaFlashBridge(String path) throws IOException { - this.iotaLibPath = path; + public static void boot() throws IOException { + String file = readFile(iotaLibPath, Charset.defaultCharset()); - String file = readFile(path, Charset.defaultCharset()); - - this.engine = V8.createV8Runtime(); + engine = V8.createV8Runtime(); // Eval lib into current v8 context. engine.executeVoidScript(file); multisig = (V8Object) engine.executeScript("iotaFlash.multisig"); transfer = (V8Object) engine.executeScript("iotaFlash.transfer"); - } /** @@ -41,9 +33,8 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param digests * @return */ - public MultisigAddress composeAddress(ArrayList digests) { + public static MultisigAddress composeAddress(ArrayList digests) { // Create js object for digest - // TODO: find more clean way to do thi s. List list = new ArrayList(); for (Digest digest: digests) { list.add(digest.toMap()); @@ -73,7 +64,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param security * @return */ - public Digest getDigest(String seed, int index, int security) { + public static Digest getDigest(String seed, int index, int security) { if (seed.length() < 81) { System.out.println("Seed is too short"); return null; @@ -94,14 +85,21 @@ public class IotaFlashBridge implements IotaFlashInterface { * * @param root */ - public void updateLeafToRoot(MultisigAddress root) { + public static CreateTransactionHelperObject updateLeafToRoot(MultisigAddress root) { Map map = root.toMap(); // Create param list List paramsObj = new ArrayList(); paramsObj.add(map); V8Array params = V8ObjectUtils.toV8Array(engine, paramsObj); - multisig.executeFunction("updateLeafToRoot", params); + V8Object ret = multisig.executeObjectFunction("updateLeafToRoot", params); + int generate = ret.getInteger("generate"); + Map multiSigMap = V8ObjectUtils.toMap((V8Object) ret.getObject("multisig")); + // Parse result into Java Obj. + String addr = (String) multiSigMap.get("address"); + int secSum = (Integer) multiSigMap.get("securitySum"); + MultisigAddress multisig = new MultisigAddress(addr, secSum); + return new CreateTransactionHelperObject(generate, multisig); } @@ -113,7 +111,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param transfers array of all transfers (value, address) pairs * @return */ - public Object prepare(ArrayList settlementAddresses, ArrayList deposits, int index, ArrayList transfers) { + public static List 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(); @@ -133,6 +131,11 @@ public class IotaFlashBridge implements IotaFlashInterface { V8Array ret = transfer.executeArrayFunction("prepare", V8ObjectUtils.toV8Array(engine, params)); List transfersReturnJS = V8ObjectUtils.toList(ret); + for (Object b: transfersReturnJS) { + Map test = V8ObjectUtils.toMap((V8Object) b); + + } + // Call js. return transfersReturnJS; } @@ -142,14 +145,14 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param balance * @param deposits * @param outputs - * @param multisig + * @param root * @param remainderAddress * @param history * @param transfers * @param close * @return */ - public List compose(int balance, ArrayList deposits, ArrayList outputs, Object multisig, String remainderAddress, ArrayList history, ArrayList transfers, boolean close) { + public static List compose(int balance, ArrayList deposits, ArrayList outputs, MultisigAddress root, String remainderAddress, ArrayList history, ArrayList transfers, boolean close) { V8Array depositsJS = V8ObjectUtils.toV8Array(engine, deposits); // Outputs List outputsObj = new ArrayList(); @@ -158,26 +161,60 @@ public class IotaFlashBridge implements IotaFlashInterface { } V8Array outputsJS = V8ObjectUtils.toV8Array(engine, outputsObj); + + List transfersObj = new ArrayList(); for (Transfer t: transfers) { transfersObj.add(t.toMap()); } V8Array transfersJS = V8ObjectUtils.toV8Array(engine, transfersObj); - List trs = V8ObjectUtils.toList(transfersJS); + // Create params. + // Now put all params into JS ready array. + List params = new ArrayList(); + params.add(balance); + params.add(depositsJS); + params.add(outputsJS); - return trs; + + // Call js function. + V8Array ret = transfer.executeArrayFunction("compose", V8ObjectUtils.toV8Array(engine, params)); + List transfersReturnJS = V8ObjectUtils.toList(ret); + + // Parse return as array of bundles + + + return transfersReturnJS; } /** * - * @param multisig + * @param root * @param seed * @param bundles * @return */ - public Object sign(Object multisig, String seed, ArrayList bundles) { - return null; + public static Object sign(MultisigAddress root, String seed, ArrayList bundles) { + Map multisig = root.toMap(); + V8Object rootJS = V8ObjectUtils.toV8Object(engine, multisig); + + List bundleTmp = new ArrayList(); + for (Bundle b: bundles) { + bundleTmp.add(b.toMap()); + } + V8Array bundlesJS = V8ObjectUtils.toV8Array(engine, bundleTmp); + + // Create params. + // Now put all params into JS ready array. + List params = new ArrayList(); + params.add(rootJS); + params.add(seed); + params.add(bundles); + + V8Object signatures = transfer.executeObjectFunction("sign", V8ObjectUtils.toV8Array(engine, params)); + + // TODO: add singature object. + return signatures; } /** @@ -186,7 +223,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param signatures * @return */ - public Object appliedSignatures(ArrayList bundles, ArrayList signatures) { + public static Object appliedSignatures(ArrayList bundles, ArrayList signatures) { return null; } @@ -198,7 +235,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param bundles * @return */ - public Object getDiff(ArrayList root, ArrayList remainder, ArrayList history, ArrayList bundles) { + public static Object getDiff(ArrayList root, ArrayList remainder, ArrayList history, ArrayList bundles) { return null; } @@ -212,7 +249,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param signedBundles * @return */ - public Object applayTransfers(Object root, Object deposit, Object outputs, Object remainderAddress, Object transfers, Object signedBundles) { + public static Object applayTransfers(Object root, Object deposit, Object outputs, Object remainderAddress, Object transfers, Object signedBundles) { return null; } @@ -222,7 +259,7 @@ public class IotaFlashBridge implements IotaFlashInterface { * @param deposits * @return */ - public Object close(ArrayList settlementAddresses, ArrayList deposits) { + public static Object close(ArrayList settlementAddresses, ArrayList deposits) { V8Array saJS = V8ObjectUtils.toV8Array(engine, settlementAddresses); // Deposits V8Array depositsJS = V8ObjectUtils.toV8Array(engine, deposits); diff --git a/src/main/java/IotaFlashInterface.java b/src/main/java/IotaFlashInterface.java index c13db4b..b1faaea 100644 --- a/src/main/java/IotaFlashInterface.java +++ b/src/main/java/IotaFlashInterface.java @@ -9,11 +9,11 @@ public interface IotaFlashInterface { // Transfer public Object prepare(ArrayList settlementAddresses, ArrayList deposits, int index, ArrayList transfers); - public List compose(int balance, ArrayList deposits, ArrayList outputs, Object multisig, String remainderAddress, ArrayList history, ArrayList transfers, boolean close); + public List compose(int balance, ArrayList deposits, ArrayList outputs, MultisigAddress root, String remainderAddress, ArrayList history, ArrayList transfers, boolean close); public Digest getDigest(String seed, int index, int security); - public Object sign(Object multisig, String seed, ArrayList bundles); + public Object sign(MultisigAddress root, String seed, ArrayList bundles); public Object appliedSignatures(ArrayList bundles, ArrayList signatures); public Object getDiff(ArrayList root, ArrayList remainder, diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 495261a..913a7a9 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -1,23 +1,182 @@ +import com.sun.org.apache.xpath.internal.operations.Mult; + +import java.io.IOException; +import java.lang.reflect.Array; import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Collectors; public class Main { - public static void main(String[] argv) throws Exception { + // Create v8 engine and load lib. + IotaFlashBridge.boot(); + + // Run a test based on the flash example + // Link: https://github.com/iotaledger/iota.flash.js/blob/master/examples/flash.js + + String oneSeed = "USERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSER"; + String oneSettlement = "USERONE9ADDRESS9USERONE9ADDRESS9USERONE9ADDRESS9USERONE9ADDRESS9USERONE9ADDRESS9U"; + String twoSeed = "USERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSERTWOUSER"; + String twoSettlement = "USERTWO9ADDRESS9USERTWO9ADDRESS9USERTWO9ADDRESS9USERTWO9ADDRESS9USERTWO9ADDRESS9U"; + + ////////////////////////////////// + // INITIAL CHANNEL CONDITIONS + + // Security level + int SECURITY = 2; + // Number of parties taking signing part in the channel + int SIGNERS_COUNT = 2; + // Flash tree depth + int TREE_DEPTH = 4; + // Total channel Balance + int CHANNEL_BALANCE = 2000; + // Users deposits + ArrayList DEPOSITS = new ArrayList<>(); + DEPOSITS.add(1000); + DEPOSITS.add(1000); + // Setup users. + FlashObject oneFlashObj = new FlashObject(SIGNERS_COUNT, CHANNEL_BALANCE, DEPOSITS); + UserObject oneFlash = new UserObject(0, oneSeed, TREE_DEPTH, oneFlashObj); + + FlashObject twoFlashObj = new FlashObject(SIGNERS_COUNT, CHANNEL_BALANCE, DEPOSITS); + UserObject twoFlash = new UserObject(1, twoSeed, TREE_DEPTH, twoFlashObj); + + // USER ONE + setupUser(oneFlash, TREE_DEPTH); + + // USER TWO + setupUser(twoFlash, TREE_DEPTH); + + ////////////////////////////////// + // INITAL MULTISIG + + // Make an array of digests + ArrayList allUsers = new ArrayList(); + allUsers.add(oneFlash); + allUsers.add(twoFlash); + + // Create partial digests for users. + createInitialPartialDigests(allUsers, oneFlash); + createInitialPartialDigests(allUsers, twoFlash); + + ArrayList oneMultisigs = oneFlash.getMultisigDigests(); + ArrayList twoMultisigs = twoFlash.getMultisigDigests(); + + // Set renainder address. + MultisigAddress oneRemainderAddr = oneMultisigs.remove(0); //shiftCopyArray(); + oneFlash.getFlash().setRemainderAddress(oneRemainderAddr); + + MultisigAddress twoRemainderAddr = twoMultisigs.remove(0); + twoFlash.getFlash().setRemainderAddress(twoRemainderAddr); + + // Build flash trees + for (int i = 1; i < oneMultisigs.size(); i++) { + System.out.println("Adding child (" + oneMultisigs.get(0).toString() + ") to root :" + oneMultisigs.get(i - 1).toString() ); + oneMultisigs.get(i - 1).push(oneMultisigs.get(i)); + } + + // Build flash trees + for (int i = 1; i < twoMultisigs.size(); i++) { + twoMultisigs.get(i - 1).push(twoMultisigs.get(i)); + } + + oneFlash.getFlash().setRoot(oneMultisigs.remove(0)); + twoFlash.getFlash().setRoot(twoMultisigs.remove(0)); + + ArrayList settlementAddresses = new ArrayList<>(); + settlementAddresses.add(oneSettlement); + settlementAddresses.add(twoSettlement); + oneFlash.getFlash().setSettlementAddresses(settlementAddresses); + twoFlash.getFlash().setSettlementAddresses(settlementAddresses); + + System.out.println("Channel Setup!"); + + + ArrayList transfers = new ArrayList<>(); + transfers.add(new Transfer(twoSettlement, 200)); + + Helpers.createTransaction(oneFlash, transfers, false); + } + + private static void setupUser(UserObject user, int TREE_DEPTH) { + // Create digests for the start of the channel + for (int i = 0; i < TREE_DEPTH + 1; i++) { + // Create new digest + Digest digest = IotaFlashBridge.getDigest( + user.getSeed(), + user.getIndex(), + user.getSecurity() + ); + System.out.println("Adding digest (" + digest.toString() + ") to user " + user.getUserIndex()); + // Increment key index + user.incrementIndex(); + user.add(digest); + } + } + + private static void createInitialPartialDigests(ArrayList allUsers, UserObject currentUser) { + + // Generate the first addresses + ArrayList oneMultisigs = new ArrayList(); + + + System.out.println("_________________________________________________________________"); + System.out.println("Creating multisigs on user: " + currentUser.getUserIndex()); + int index = 0; + // Create address + for (Digest digest: allUsers.get(index).getPartialDigests()) { + int i = index; + + MultisigAddress addy = IotaFlashBridge.composeAddress( + allUsers.stream().map(u -> u.getPartialDigests().get(i)).collect(Collectors.toCollection(ArrayList::new)) + ); + + System.out.println("Multisig: " + addy.toString()); + + // Add key index in + addy.setIndex(digest.getIndex()); + // Add the signing index to the object IMPORTANT + addy.setSigningIndex(currentUser.getUserIndex() * digest.getSecurity()); + // Get the sum of all digest security to get address security sum + addy.setSecuritySum(allUsers.stream() + .map(u -> u.getPartialDigests().get(i)) + .mapToInt(Digest::getSecurity) + .sum() + ); + addy.setSecurity(digest.getSecurity()); + oneMultisigs.add(addy); + index++; + } + currentUser.setMultisigDigests(oneMultisigs); + } + + private static ArrayList shiftCopyArray(ArrayList input) { + ArrayList output = new ArrayList<>(); + + for (int i = 1; i < input.size(); i++) { + output.add(input.get(i)); + } + + return output; + } + + private static void test() throws IOException { + System.out.println("IOTA Flash channel tester"); String pathToLib = "res/iota.flash.js"; System.out.println("Loading lib into V8 engine"); - IotaFlashInterface lib = new IotaFlashBridge(pathToLib); System.out.println("Lib imported"); System.out.println("Testing getDigest(seed, index, security):"); - Digest digest1 = lib.getDigest("USERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSER", 0, 2); - Digest digest2 = lib.getDigest("USERTWOUSERTWOUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSER", 0, 2); + Digest digest1 = IotaFlashBridge.getDigest("USERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSER", 0, 2); + Digest digest2 = IotaFlashBridge.getDigest("USERTWOUSERTWOUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSERONEUSER", 0, 2); System.out.println("Digest1: " + digest1.toString()); @@ -25,13 +184,13 @@ public class Main { ArrayList digests = new ArrayList(); digests.add(digest1); digests.add(digest2); - MultisigAddress composedAddr = lib.composeAddress(digests); + MultisigAddress composedAddr = IotaFlashBridge.composeAddress(digests); System.out.println("Got multisig addr for digests: " + composedAddr.getAddress() + ", securitySum: " + composedAddr.getSecuritySum()); - testPrepare(lib); + testPrepare(); } - private static void testPrepare(IotaFlashInterface lib) { + private static void testPrepare() { System.out.println("Testing prepare()"); ArrayList settlementAddr = new ArrayList(); @@ -39,6 +198,6 @@ public class Main { ArrayList depositsPrep = new ArrayList(); ArrayList transfers = new ArrayList(); - lib.prepare(settlementAddr, depositsPrep, 0, transfers); + IotaFlashBridge.prepare(settlementAddr, depositsPrep, 0, transfers); } } diff --git a/src/main/java/MultisigAddress.java b/src/main/java/MultisigAddress.java index b879d82..afa69f0 100644 --- a/src/main/java/MultisigAddress.java +++ b/src/main/java/MultisigAddress.java @@ -1,11 +1,36 @@ +import com.eclipsesource.v8.V8; +import com.eclipsesource.v8.V8Object; +import com.eclipsesource.v8.utils.V8ObjectUtils; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +class CreateTransactionHelperObject { + private int generate = 0; + private MultisigAddress address; + + CreateTransactionHelperObject(int gen, MultisigAddress addr) { + this.generate = gen; + this.address = addr; + } + + public int getGenerate() { + return generate; + } + + public MultisigAddress getAddress() { + return address; + } +} + class MultisigAddress { private String address; private int securitySum; + private int index; + private int signingIndex; + private int security; private ArrayList children; private ArrayList bundles; @@ -17,6 +42,10 @@ class MultisigAddress { } + public void push(MultisigAddress addr) { + children.add(addr); + } + public ArrayList getChildren() { return children; } @@ -28,6 +57,33 @@ class MultisigAddress { public String getAddress() { return address; } + public int getIndex() { + return index; + } + + public int getSigningIndex() { + return signingIndex; + } + + public int getSecurity() { + return security; + } + + public void setIndex(int index) { + this.index = index; + } + + public void setSecurity(int security) { + this.security = security; + } + + public void setSecuritySum(int securitySum) { + this.securitySum = securitySum; + } + + public void setSigningIndex(int signingIndex) { + this.signingIndex = signingIndex; + } public Map toMap() { Map map = new HashMap(); @@ -41,11 +97,20 @@ class MultisigAddress { map.put("children", childrenList); List bundleList = new ArrayList(); - for (MultisigAddress ma: children) { - bundleList.add(ma.toMap()); + for (Bundle b: bundles) { + bundleList.add(b.getBundles()); } map.put("bundle", bundleList); return map; } + + public V8Object toV8Object(V8 engine) { + return V8ObjectUtils.toV8Object(engine, this.toMap()); + } + + @Override + public String toString() { + return "{'address':'" + address + "', securitySum:" + securitySum + ", signingIndex: " + signingIndex + "}"; + } } \ No newline at end of file diff --git a/src/main/java/UserObject.java b/src/main/java/UserObject.java new file mode 100644 index 0000000..4bc47b8 --- /dev/null +++ b/src/main/java/UserObject.java @@ -0,0 +1,108 @@ +import java.util.ArrayList; + +public class UserObject { + private int userIndex = 1; + private String seed; + private int index = 0; + private int security = 2; + private int depth = 4; + private ArrayList bundles = new ArrayList(); + private ArrayList partialDigests = new ArrayList(); + private ArrayList multisigDigests = new ArrayList(); + private FlashObject flash; + + UserObject(int userID, String seed, int depth, FlashObject flash) { + this.userIndex = userID; + this.seed = seed; + this.depth = depth; + this.flash = flash; + } + + public void incrementIndex() { + index++; + } + + public void add(Digest digest) { + partialDigests.add(digest); + } + + + /** + * + * Getters and Setters + */ + + public void setMultisigDigests(ArrayList multisigDigests) { + this.multisigDigests = multisigDigests; + } + + public ArrayList getMultisigDigests() { + return multisigDigests; + } + + public int getSecurity() { + return security; + } + + public String getSeed() { + return seed; + } + + public int getIndex() { + return index; + } + + public int getUserIndex() { + return userIndex; + } + + public ArrayList getBundles() { + return bundles; + } + + public ArrayList getPartialDigests() { + return partialDigests; + } + + public FlashObject getFlash() { + return flash; + } + +} + +class FlashObject { + int signersCount = 2; + int balance; + ArrayList settlementAddresses; + MultisigAddress root; + MultisigAddress remainderAddress; + ArrayList deposits; // Clone correctly + ArrayList outputs = new ArrayList(); + ArrayList transfers = new ArrayList(); + + FlashObject(int signersCount, int balance, ArrayList deposits) { + this.signersCount = signersCount; + this.balance = balance; + this.deposits = deposits; + } + + public void setRemainderAddress(MultisigAddress remainderAddress) { + this.remainderAddress = remainderAddress; + } + + public MultisigAddress getRemainderAddress() { + return remainderAddress; + } + + public void setRoot(MultisigAddress root) { + this.root = root; + } + + public void setSettlementAddresses(ArrayList settlementAddresses) { + this.settlementAddresses = settlementAddresses; + } + + public ArrayList getSettlementAddresses() { + return settlementAddresses; + } +}