/** * Get contracts current contract revokes upon registration * @return contracts to be revoked */ public List<Contract> getRevoking() { return new ArrayList<Contract>((Collection) getRevokingItems()); }
private Contract joinAndRemoveFromContracts(List<Contract> selectedContracts) throws Exception { Contract result = selectedContracts.get(0).copy(); result.getRevokingItems().addAll(selectedContracts); this.contracts.removeAll(selectedContracts); result.setKeysToSignWith(selectedContracts.get(0).getKeysToSignWith()); return result; }
/** * Trace the tree of contracts subItems on the stdout. */ public void trace() { System.out.println("Transaction pack"); System.out.println("\tContract:"); System.out.println("\t\t" + contract.getId()); contract.getNewItems().forEach(x -> System.out.println("\t\t\tnew: " + x.getId())); contract.getRevokingItems().forEach(x -> System.out.println("\t\t\trevoke: " + x.getId())); System.out.println("\tSubItems:"); subItems.forEach((hashId, contract) -> System.out.println("\t\t" + hashId + " -> " + contract.getId())); }
private void checkMerge(Contract changed, MapDelta<String, Binder, Binder> dataChanges, Set<Contract> revokingItems, Collection<PublicKey> keys, Decimal newValue) { boolean isValid; // merge means there are mergeable contracts in the revoking items Decimal sum = Decimal.ZERO; Set<Contract> revokesToRemove = new HashSet<>(); for (Approvable a : changed.getRevokingItems()) { if (a instanceof Contract) { Contract c = (Contract) a; if (!isMergeable(c) || !validateMergeFields(changed, c) || !hasSimilarPermission(c, keys,true)) continue; revokesToRemove.add(c); sum = sum.add(new Decimal(getFieldName(c))); } } isValid = sum.compareTo(newValue) == 0; if (!isValid) { revokesToRemove.clear(); isValid = checkSplitJoinCase(changed, revokesToRemove, keys); } if (isValid) { dataChanges.remove(fieldName); revokingItems.removeAll(revokesToRemove); } }
private void checkStateChange() throws Quantiser.QuantiserException { stateChanges = stateDelta.getChanges(); revokingItems = new HashSet(changed.getRevokingItems()); stateChanges.remove("created_by");
private static void saveContractSubitems(String source, String suffix, Contract contract) throws IOException { try { report("unpack contract from " + source); int i = 1; if (contract.getNewItems() != null) { for (Approvable newItem : contract.getNewItems()) { String newItemFileName = new FilenameTool(source).addSuffixToBase(suffix+"_new_item_" + i).toString(); report("save newItem to " + newItemFileName); // ((Contract) newItem).seal(); saveContract((Contract) newItem, newItemFileName); i++; } } i = 1; if (contract.getRevokingItems() != null) { for (Approvable revokeItem : contract.getRevokingItems()) { String revokeItemFileName = new FilenameTool(source).addSuffixToBase(suffix+"_revoke_" + i).setExtension("unicon").toString(); report("save revokeItem to " + revokeItemFileName); saveContract((Contract) revokeItem, revokeItemFileName); i++; } } } catch (Quantiser.QuantiserException e) { addError("QUANTIZER_COST_LIMIT", contract.toString(), e.getMessage()); } }
public void checkSimplePack(TransactionPack tp) { assertEquals(3, tp.getSubItems().size()); assertEquals(c.getId(), tp.getContract().getId()); Set<HashId> rids = c.getRevokingItems().stream().map(x->x.getId()).collect(Collectors.toSet()); Set<HashId> nids = c.getNewItems().stream().map(x->x.getId()).collect(Collectors.toSet()); assertTrue(rids.contains(r0.getId())); assertTrue(nids.contains(n0.getId())); assertTrue(nids.contains(n1.getId())); }
@Test public void packedContractNotContainsOtherItems() throws Exception { // if we seal and load a contract without a pack, it should have empty // containers for new and revoking items - these should be fill separately. Contract c2 = new Contract(c.seal()); assertEquals(0, c2.getRevokingItems().size()); assertEquals(0, c2.getNewItems().size()); }
tc.createRole("creator", issuerRole); if (!tc.getRevokingItems().contains(c)) { Binder data = tc.getDefinition().getData(); List<Binder> actions = data.getOrCreateList("actions"); tc.getRevokingItems().add(c); actions.add(Binder.fromKeysValues("action", "remove", "id", c.getId()));
protected synchronized void addDetailsToAllLedgers(Contract contract) { HashId id; StateRecord orCreate; for (Approvable c : contract.getRevokingItems()) { id = c.getId(); for (Node nodeS : nodesMap.values()) { orCreate = nodeS.getLedger().findOrCreate(id); orCreate.setState(ItemState.APPROVED).save(); } } destroyFromAllNodesExistingNew(contract); destroyCurrentFromAllNodesIfExists(contract); }
List<Approvable> r1 = new ArrayList<>(c.getRevokingItems()); List<Approvable> r2 = new ArrayList<>(c1.getRevokingItems());
private boolean checkSplitJoinCase(Contract changed, Set<Contract> revokesToRemove, Collection<PublicKey> keys) { Decimal splitJoinSum = Decimal.ZERO; for (Contract c : changed.getSiblings()) { if (!isMergeable(c) || !validateMergeFields(changed, c) || !hasSimilarPermission(c, keys, false)) continue; splitJoinSum = splitJoinSum.add(new Decimal(c.getStateData().getString(fieldName))); } Decimal rSum = Decimal.ZERO; for (Approvable r : changed.getRevokingItems()) { if (r instanceof Contract) { Contract c = (Contract) r; if (!isMergeable(c) || !validateMergeFields(changed, c) || !hasSimilarPermission(c, keys, true)) continue; revokesToRemove.add(c); rSum = rSum.add(new Decimal(((Contract) r).getStateData().getString(fieldName))); } } return splitJoinSum.compareTo(rSum) == 0; }
@Test public void newRevision() throws Exception { Contract c = Contract.fromDslFile(ROOT_CONTRACT); c.addSignerKeyFromFile(PRIVATE_KEY_PATH); byte[] sealed = c.seal(); assertTrue(c.check()); Contract c2 = c.createRevision(TestKeys.privateKey(0), TestKeys.privateKey(3)); assertEquals(1, c2.getRevokingItems().size()); assertEquals(c, c2.getRevokingItems().iterator().next()); assertEquals(2, c2.getKeysToSignWith().size()); assertEquals(2, c2.getRevision()); assertEquals(c.getId(), c2.getParent()); assertEquals(c.getId(), c2.getRawOrigin()); c2.seal(); Contract c3 = c2.createRevision(TestKeys.privateKey(0), TestKeys.privateKey(3)); assertEquals(1, c3.getRevokingItems().size()); assertEquals(c2, c3.getRevokingItems().iterator().next()); assertEquals(2, c3.getKeysToSignWith().size()); assertEquals(3, c3.getRevision()); assertEquals(c2.getId(), c3.getParent()); assertEquals(c.getId(), c3.getRawOrigin()); // c2.check(); // c2.traceErrors(); }
for (int i = 0; i < 6; i++) { if(i < 5) { forJoin.getRevokingItems().add(splittedList.get(i)); } else { Contract splitting = splittedList.get(i).createRevision(); splitting.addSignerKeyFromFile(privateKeyPath); sealCheckTrace(splitting, true); forJoin.getRevokingItems().add(splitting); forJoin.addNewItems(splittedChanges);
System.out.println("check after split (c1.origin): " + c1.getOrigin().toBase64String()); System.out.println("check after split (c2.origin): " + c2.getOrigin().toBase64String()); ((Contract)c1.getRevokingItems().iterator().next()).getStateData().set("amount", 2000); c1.addSignerKey(key); c1.seal();
@Test public void shouldNotJoinWithWrongParent() throws Exception { Contract c = createCoin(); c.addSignerKeyFromFile(PRIVATE_KEY_PATH); Contract c1 = c.splitValue(FIELD_NAME, new Decimal(1)); Contract.ContractDev dev = c1.new ContractDev(c1); //Check after split. sealCheckTrace(c, true); //Set wrong parent HashId parent = HashId.withDigest(Do.randomNegativeBytes(64)); HashId origin = HashId.withDigest(Do.randomNegativeBytes(64)); dev.setParent(parent); dev.setOrigin(origin); c.getRevokingItems().add(dev.getContract()); sealCheckTrace(c, false); }
for (Approvable ri : getRevokingItems()) { if (ri.getExpiresAt().isAfter(expirationLimit)) { isSuitableForTestnet = false;
@Test public void testJoinSum() throws Exception { Contract c = createCoin(); c.addSignerKeyFromFile(PRIVATE_KEY_PATH); Binder d = c.getStateData(); int a = 1000000; assertEquals(a, d.getIntOrThrow(FIELD_NAME)); c.seal(); c.check(); c.traceErrors(); assertTrue(c.check()); // bad split: no changes Contract c1 = c.createRevision(ownerKey2); sealCheckTrace(c1, false); // Good split Contract c2 = c1.splitValue(FIELD_NAME, new Decimal(500)); assertEquals(a - 500, c1.getStateData().getIntOrThrow(FIELD_NAME)); assertEquals(500, c2.getStateData().getIntOrThrow(FIELD_NAME)); c1.getErrors().clear(); sealCheckTrace(c1, true); Contract c3 = c1.createRevision(ownerKey2); c3.getRevokingItems().add(c2); c3.getStateData().set(FIELD_NAME, new Decimal(a)); sealCheckTrace(c3, true); }
@Test public void shouldNotJoinWithWrongAmount() throws Exception { int amount = 1000000; int v = 1; Contract c = createCoin(); c.addSignerKeyFromFile(PRIVATE_KEY_PATH); sealCheckTrace(c, true); // Split with 1 Contract c2 = c.splitValue(FIELD_NAME, new Decimal(v)); assertEquals(amount - v, c.getStateData().getIntOrThrow(FIELD_NAME)); assertEquals(v, c2.getStateData().getIntOrThrow(FIELD_NAME)); sealCheckTrace(c2, true); Contract c3 = c.createRevision(ownerKey2); c3.getRevokingItems().add(c2); //Trying to hack the join and get bigger amount c3.getStateData().set(FIELD_NAME, new Decimal(v + 1)); assertEquals(amount - v, c.getStateData().getIntOrThrow(FIELD_NAME)); assertEquals(v + 1, c3.getStateData().getIntOrThrow(FIELD_NAME)); sealCheckTrace(c3, false); }
for (Approvable c : finalC.getRevokingItems()) { id = c.getId(); for (int i = 0; i < nodes.size(); i++) {