@Test public void defaultParameters() throws Exception { Contract contract = new Contract(TestKeys.privateKey(0)); contract.getStateData().put("field1", "33.000000000000000001"); ChangeNumberPermission changeNumberPermission = new ChangeNumberPermission(contract.getRole("owner"), Binder.of("field_name", "field1")); contract.addPermission(changeNumberPermission); contract.seal(); Contract changed = contract.createRevision(); changed.addSignerKey(TestKeys.privateKey(0)); changed.getStateData().set("field1", "33.000000000000000002"); changed.seal(); changed.check(); assertTrue(changed.isOk()); }
/** * Create a batch contract, which registers all the included contracts, possibily referencing each other, * in the single transaction, saving time and reducing U cost. Note that if any of the batched contracts * fails, the whole batch is rejected. * * @param contracts to register all in one batch. Shuld be prepared and sealed. * @param keys to sign batch with. * @return batch contract that includes all contracts as new items. */ public static Contract createBatch(Collection<PrivateKey> keys, Contract... contracts) { Contract batch = new Contract(); batch.setIssuerKeys(keys); batch.registerRole(new RoleLink("creator","issuer")); batch.registerRole(new RoleLink("owner","issuer")); batch.setExpiresAt(ZonedDateTime.now().plusDays(3)); for(Contract c : contracts) { batch.addNewItems(c); } batch.addSignerKeys(keys); batch.seal(); return batch; }
static Contract createComplexConctract(PrivateKey key, int subcontracts, int n) { Contract root = createSimpleContract(key); for(int i = 0; i < subcontracts; i++) { Contract c = createSimpleContract(key); c.setExpiresAt(c.getExpiresAt().plusSeconds(i+1+(subcontracts+1)*n)); c.seal(); root.addNewItems(c); } root.setExpiresAt(root.getExpiresAt().plusSeconds((subcontracts+1)*n)); root.addSignerKey(key); root.seal(); return root; }
public synchronized static Contract finishSwap(Contract swapContract, Set<PrivateKey> keys) { List<Contract> swappingContracts = (List<Contract>) swapContract.getNew(); boolean willBeMine = c.getOwner().isAllowedForKeys(keys); c.addSignatureToSeal(keys); swapContract.seal(); swapContract.addSignatureToSeal(keys);
@Test public void checkContractCreatedAtFutureTime() throws Exception{ Contract futureContract = Contract.fromDslFile(rootPath + "simple_root_contract_future.yml"); futureContract.addSignerKeyFromFile(rootPath+"_xer0yfe2nn1xthc.private.unikey"); futureContract.seal(); futureContract.check(); futureContract.traceErrors(); System.out.println("Contract is valid: " + futureContract.isOk()); assertFalse(futureContract.isOk()); }
@Test public void refMissingField() throws Exception { Contract contractA = new Contract(new PrivateKey(2048)); contractA.getStateData().put("another_val", 100); Contract contractB = new Contract(new PrivateKey(2048)); Reference ref = new Reference(); ref.type = Reference.TYPE_EXISTING_STATE; ref.setConditions(Binder.of( Reference.conditionsModeType.all_of.name(), asList("ref.state.data.val>-100") )); contractB.addReference(ref); Contract batch = new Contract(new PrivateKey(2048)); batch.addNewItems(contractA); batch.addNewItems(contractB); batch.seal(); Boolean res = batch.check(); batch.traceErrors(); assertEquals(false, res); }
@Test public void checkFitTestnetCriteria() throws Exception { PrivateKey key = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")); Contract contract = Contract.fromDslFile(rootPath + "LamborghiniTestDrive.yml"); contract.setExpiresAt(ZonedDateTime.now().plusMonths(1)); contract.addSignerKey(key); sealCheckTrace(contract, true); System.out.println("Processing cost is " + contract.getProcessedCostU()); assertTrue(contract.isSuitableForTestnet()); // now set contract limited for testnet contract.setLimitedForTestnet(true); sealCheckTrace(contract, true); assertTrue(contract.isSuitableForTestnet()); }
@Test public void goodNotary() throws Exception { Set<PrivateKey> martyPrivateKeys = new HashSet<>(); Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); Set<PublicKey> martyPublicKeys = new HashSet<>(); Set<PublicKey> stepaPublicKeys = new HashSet<>(); martyPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/marty_mcfly.private.unikey"))); stepaPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey"))); for (PrivateKey pk : stepaPrivateKeys) stepaPublicKeys.add(pk.getPublicKey()); for (PrivateKey pk : martyPrivateKeys) martyPublicKeys.add(pk.getPublicKey()); Contract notaryContract = ContractsService.createNotaryContract(martyPrivateKeys, stepaPublicKeys); notaryContract.check(); notaryContract.traceErrors(); assertTrue(notaryContract.isOk()); assertTrue(notaryContract.getOwner().isAllowedForKeys(stepaPublicKeys)); assertTrue(notaryContract.getIssuer().isAllowedForKeys(martyPrivateKeys)); assertTrue(notaryContract.getCreator().isAllowedForKeys(martyPrivateKeys)); assertFalse(notaryContract.getOwner().isAllowedForKeys(martyPrivateKeys)); assertFalse(notaryContract.getIssuer().isAllowedForKeys(stepaPublicKeys)); assertFalse(notaryContract.getCreator().isAllowedForKeys(stepaPublicKeys)); assertTrue(notaryContract.getExpiresAt().isAfter(ZonedDateTime.now().plusMonths(3))); assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now())); assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys)); assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys)); assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys)); assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys)); }
@Test public void registerSimpleContractWhite() throws Exception { Contract whiteContract = new Contract(TestKeys.privateKey(0)); whiteContract.seal(); System.out.println("whiteClient.register(whiteContract)..."); ItemResult itemResult = whiteClient.register(whiteContract.getPackedTransaction(), 5000); System.out.println("whiteClient.register(whiteContract)... done! itemResult: " + itemResult.state); itemResult = whiteClient.getState(whiteContract.getId()); System.out.println("whiteClient.getState(whiteContract): " + itemResult.state); assertEquals(ItemState.APPROVED, itemResult.state); }
@Test public void references() throws Exception { Contract contract = new Contract(TestKeys.privateKey(0)); String js = ""; js += "print('references');"; js += "var ref = jsApi.getReferenceBuilder().createReference('EXISTING_STATE');"; js += "ref.setConditions({'all_of':['ref.issuer=="+TestKeys.publicKey(1).getShortAddress().toString()+"']});"; js += "jsApi.getCurrentContract().addReference(ref);"; contract.getState().setJS(js.getBytes(), "client script.js", new JSApiScriptParameters()); contract.seal(); contract = Contract.fromPackedTransaction(contract.getPackedTransaction()); Contract batchContract = new Contract(TestKeys.privateKey(3)); batchContract.addNewItems(contract); batchContract.seal(); assertTrue(batchContract.check()); contract.execJS(new JSApiExecOptions(), js.getBytes()); contract.seal(); batchContract.seal(); assertFalse(batchContract.check()); }
@Test public void issuerTest() throws Exception { KeyAddress keyAddress1 = TestKeys.privateKey(0).getPublicKey().getShortAddress(); KeyAddress keyAddress2 = TestKeys.privateKey(1).getPublicKey().getShortAddress(); Contract contract = new Contract(TestKeys.privateKey(2)); contract.setCreatorKeys(keyAddress1); contract.setIssuerKeys(keyAddress2); contract.addSignerKey(TestKeys.privateKey(0)); contract.seal(); assertFalse(contract.check()); contract.setIssuerKeys(keyAddress1); contract.getErrors().clear(); contract.seal(); assertTrue(contract.check()); }
@Test public void registerSimpleContract_getStateOnly() throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); Set<PublicKey> stepaPublicKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); for (PrivateKey pk : stepaPrivateKeys) { stepaPublicKeys.add(pk.getPublicKey()); } Contract stepaCoins = Contract.fromDslFile(ROOT_PATH + "stepaCoins.yml"); stepaCoins.addSignerKey(stepaPrivateKeys.iterator().next()); stepaCoins.seal(); ItemResult itemResult = nodeClient.getState(stepaCoins.getId()); System.out.println("nodeClient.getState(stepaCoins): " + itemResult.state); assertEquals(ItemState.APPROVED, itemResult.state); }
@Test public void goodRevoke() throws Exception { Contract c = Contract.fromDslFile(rootPath + "simple_root_contract.yml"); c.addSignerKeyFromFile(rootPath+"_xer0yfe2nn1xthc.private.unikey"); PrivateKey goodKey = c.getKeysToSignWith().iterator().next(); c.setOwnerKeys(new KeyRecord(goodKey.getPublicKey())); c.seal(); Contract revokeContract = c.createRevocation(goodKey); revokeContract.check(); assertTrue(revokeContract.isOk()); // tc.traceErrors(); }
public TestContracts invoke() throws EncryptionError, Quantiser.QuantiserException { r0 = new Contract(TestKeys.privateKey(0)); r0.seal(); c = r0.createRevision(TestKeys.privateKey(0)); n0 = new Contract(TestKeys.privateKey(0)); n1 = new Contract(TestKeys.privateKey(0)); c.addNewItems(n0); c.addNewItems(n1); c.seal(); return this; } }
stepaPublicKeys.add(pk.getPublicKey()); Contract baseContract = Contract.fromDslFile(ROOT_PATH + "DeLoreanOwnership.yml"); PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); baseContract.addSignerKey(manufacturePrivateKey); baseContract.seal(); System.out.println("Base contract contract is valid: " + baseContract.isOk()); twoSignContract.addSignatureToSeal(stepaPrivateKeys); twoSignContract.check(); twoSignContract.traceErrors(); registerAndCheckDeclined(twoSignContract); twoSignContract.addSignatureToSeal(martyPrivateKeys); twoSignContract.check(); twoSignContract.traceErrors(); System.out.println("Contract with two signature is valid: " + twoSignContract.isOk()); registerAndCheckApproved(twoSignContract);
@Test(timeout = 15000) public void resyncApproved() throws Exception { Contract c = new Contract(TestKeys.privateKey(0)); c.seal(); addToAllLedgers(c, ItemState.APPROVED); node.getLedger().getRecord(c.getId()).destroy(); assertEquals(ItemState.UNDEFINED, node.checkItem(c.getId()).state); node.resync(c.getId()); assertEquals(ItemState.APPROVED, node.waitItem(c.getId(), 15000).state); }
public void asd() throws Exception { PrivateKey key = new PrivateKey(Do.read("/Users/romanu/Downloads/ru/roman.uskov.privateKey.unikey")); Set<PrivateKey> issuers = new HashSet<>(); issuers.add(key); Set<PublicKey> owners = new HashSet<>(); owners.add(key.getPublicKey()); TestSpace testSpace = prepareTestSpace(); testSpace.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); for(int i = 109; i < 110; i++) { Contract c = ContractsService.createTokenContract(issuers, owners, new BigDecimal("100000.9"), new BigDecimal("0.01")); c.setIssuerKeys(key.getPublicKey().getShortAddress()); c.setCreatorKeys(key.getPublicKey().getShortAddress()); c.setExpiresAt(ZonedDateTime.now().plusDays(10)); c.seal(); new FileOutputStream("/Users/romanu/Downloads/ru/token"+i+".unicon").write(c.getPackedTransaction()); assertEquals(testSpace.client.register(Contract.fromPackedTransaction(Do.read("/Users/romanu/Downloads/ru/token"+i+".unicon")).getPackedTransaction(),10000).state,ItemState.APPROVED); } }
@Test public void checkAnonymizingRole() throws Exception { PrivateKey key = new PrivateKey(Do.read(PRIVATE_KEY_PATH)); Contract contract = createCoin100apiv3(); contract.addSignerKey(key); sealCheckTrace(contract, true); assertTrue(contract.getIssuer().getKeys().contains(key.getPublicKey())); contract.anonymizeRole("issuer"); contract.anonymizeRole("owner"); contract.seal(); assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey())); Contract anonPublishedContract = new Contract(contract.getLastSealedBinary()); assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey())); // assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey())); }
private Contract basicContractCreation(final String fileName, final String keyFileName, final PrivateKey key) throws Exception { Contract c = Contract.fromDslFile(rootPath + fileName); c.setOwnerKey(key); c.addSignerKeyFromFile(rootPath + keyFileName); c.seal(); c.check(); c.traceErrors(); assertTrue(c.check()); return c; }
@Test public void checkPaymentContract() throws Exception { // to register manually, execute from deploy project: // bin/sql_all pro "insert into ledger(hash,state,created_at, expires_at, locked_by_id) values(decode('9186C0A9E9471E4559E74B5DAC3DBBB8445807DF80CAE4CE06FDB6588FAEBA1CE004AD378BEF3C445DECF3375E3CA5FD16227DBE5831A21207BB1BD21C85F30D0CED014E152F77E62082E0442FBD9FD2458C20778F7501B5D425AF9984062E54','hex'),'4','1520977039','1552513039','0');" // to erase all ledgers, execute: // bin/sql_all pro "truncate table ledger" // (after erasing ledgers, items still stay in cache -> need to restart (or redeploy) nodes) Contract contract = paymentContract; contract.check(); System.out.println("uno bin: " + Base64.encodeString(contract.getPackedTransaction())); System.out.println("uno hashId: " + Bytes.toHex(contract.getId().getDigest()).replace(" ", "")); System.out.println("approved ord: " + ItemState.APPROVED.ordinal()); System.out.println("getCreatedAt: " + StateRecord.unixTime(contract.getCreatedAt())); System.out.println("getExpiresAt: " + StateRecord.unixTime(contract.getExpiresAt())); ItemResult itemResult = normalClient.getState(contract.getId()); System.out.println("getState... done! itemResult: " + itemResult.state); }