/** * Create paid transaction, which consist from contract you want to register and payment contract that will be * spend to process transaction. * <br><br> * * @param payload is prepared contract you want to register in the Universa. * @param payment is approved contract with "U" belongs to you. * @param amount is number of "U" you want to spend to register payload contract. * @param keys is own private keys, which are set as owner of payment contract * @return parcel, it ready to send to the Universa. */ public synchronized static Parcel createParcel(Contract payload, Contract payment, int amount, Set<PrivateKey> keys) { return createParcel(payload, payment, amount, keys, false); }
/** * Create paid transaction, which consist from prepared TransactionPack you want to register * and payment contract that will be * spend to process transaction. * <br><br> * * @param payload is prepared TransactionPack you want to register in the Universa. * @param payment is approved contract with "U" belongs to you. * @param amount is number of "U" you want to spend to register payload contract. * @param keys is own private keys, which are set as owner of payment contract * @return parcel, it ready to send to the Universa. */ public synchronized static Parcel createParcel(TransactionPack payload, Contract payment, int amount, Set<PrivateKey> keys) { return createParcel(payload, payment, amount, keys, false); }
public synchronized Parcel createParcelWithClassU(Contract c, Set<PrivateKey> keys) throws Exception { Contract u = getApprovedUContract(); Parcel parcel = ContractsService.createParcel(c, u, 150, keys); return parcel; }
public synchronized Parcel createParcelWithClassU(Contract c, Set<PrivateKey> keys) throws Exception { Contract u = getApprovedUContract(); Parcel parcel = ContractsService.createParcel(c, u, 150, keys); // System.out.println("create parcel: " + parcel.getId() + " " + parcel.getPaymentContract().getId() + " " + parcel.getPayloadContract().getId()); return parcel; }
/** * Register a specified contract. * * @param contract must be a sealed binary. */ public static Parcel prepareForRegisterContract(Contract contract, Contract u, int amount, Set<PrivateKey> uKeys, boolean withTestPayment) throws IOException { List<ErrorRecord> errors = contract.getErrors(); if (errors.size() > 0) { report("contract has errors and can't be submitted for registration"); report("contract id: " + contract.getId().toBase64String()); addErrors(errors); } else { Parcel parcel = ContractsService.createParcel(contract, u, amount, uKeys, withTestPayment); return parcel; } return null; }
protected synchronized Parcel registerWithNewParcel(TransactionPack tp) throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Contract tu = getApprovedUContract(); // stepaPrivateKeys - is also U keys Parcel parcel = ContractsService.createParcel(tp, tu, 150, stepaPrivateKeys); System.out.println("-------------"); node.registerParcel(parcel); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } return parcel; }
protected synchronized Parcel registerWithNewParcel(TransactionPack tp) throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Contract tu = getApprovedUContract(); // stepaPrivateKeys - is also U keys Parcel parcel = ContractsService.createParcel(tp, tu, 150, stepaPrivateKeys); System.out.println("-------------"); normalClient.registerParcelWithState(parcel.pack(),8000); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } return parcel; }
public synchronized Parcel createParcelWithFreshU(Contract c, Set<PrivateKey> keys) throws Exception { Set<PublicKey> ownerKeys = new HashSet(); keys.stream().forEach(key -> ownerKeys.add(key.getPublicKey())); Contract stepaU = InnerContractsService.createFreshU(100000000, ownerKeys); stepaU.check(); //stepaU.setIsU(true); stepaU.traceErrors(); node.registerItem(stepaU); ItemResult itemResult = node.waitItem(stepaU.getId(), 18000); assertEquals(ItemState.APPROVED, itemResult.state); return ContractsService.createParcel(c, stepaU, 150, keys); }
public synchronized Parcel createParcelWithFreshU(Client client, Contract c, Collection<PrivateKey> keys) throws Exception { Set<PublicKey> ownerKeys = new HashSet(); keys.stream().forEach(key->ownerKeys.add(key.getPublicKey())); Contract stepaU = InnerContractsService.createFreshU(100000000, ownerKeys); stepaU.check(); //stepaU.setIsU(true); stepaU.traceErrors(); PrivateKey clientPrivateKey = client.getSession().getPrivateKey(); PrivateKey newPrivateKey = new PrivateKey(Do.read("./src/test_contracts/keys/u_key.private.unikey")); client.getSession().setPrivateKey(newPrivateKey); client.restart(); Thread.sleep(8000); ItemResult itemResult = client.register(stepaU.getPackedTransaction(), 5000); // node.registerItem(stepaU); // ItemResult itemResult = node.waitItem(stepaU.getId(), 18000); client.getSession().setPrivateKey(clientPrivateKey); client.restart(); Thread.sleep(8000); assertEquals(ItemState.APPROVED, itemResult.state); Set<PrivateKey> keySet = new HashSet<>(); keySet.addAll(keys); return ContractsService.createParcel(c, stepaU, 150, keySet); }
@Test(timeout = 90000) public void declinePaymentAndPaymentWithRemovedPermissions() throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Contract uContract = getApprovedUContract(); Contract modifiedU = uContract.createRevision(stepaPrivateKeys); modifiedU.getPermissions().remove("revoke"); modifiedU.seal(); // stepaPrivateKeys - is also U keys Parcel parcel = ContractsService.createParcel(modifiedU, uContract, 150, stepaPrivateKeys); System.out.println("-------------"); node.registerParcel(parcel); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } waitAndCheckState(parcel, ItemState.UNDEFINED); }
@Ignore @Test public void registerSeveralSimpleContractWithPayment() throws Exception { for (int i = 0; i < 20; ++i) { System.out.println("\ni = " + i); Contract contractToRegister = new Contract(TestKeys.privateKey(10)); contractToRegister.seal(); ItemResult itemResult = normalClient.register(contractToRegister.getPackedTransaction(), 5000); System.out.println("register... done! itemResult: " + itemResult.state); assertEquals(ItemState.UNDEFINED, itemResult.state); Parcel parcel = ContractsService.createParcel(contractToRegister, paymentContract, 1, Stream.of(paymentContractPrivKey).collect(Collectors.toSet()), true); normalClient.registerParcelWithState(parcel.pack(), 5000); itemResult = normalClient.getState(parcel.getPaymentContract().getId()); if (itemResult.state == ItemState.APPROVED) paymentContract = parcel.getPaymentContract(); System.out.println("registerParcel... done!"); System.out.println("parcel.paymentContract.itemResult: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = normalClient.getState(contractToRegister.getId()); System.out.println("contractToRegister.itemResult: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); } }
@Test public void paymentTest1() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Contract simpleContract = new Contract(TestKeys.privateKey(1)); simpleContract.seal(); Contract stepaU = InnerContractsService.createFreshU(100000000, new HashSet<>(Arrays.asList(TestKeys.publicKey(1)))); ItemResult itemResult = client.register(stepaU.getPackedTransaction(), 5000); System.out.println("stepaU itemResult: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); main.config.setIsFreeRegistrationsAllowedFromYaml(false); Parcel parcel = ContractsService.createParcel(simpleContract, stepaU, 1, new HashSet<>(Arrays.asList(TestKeys.privateKey(1))), false); client.registerParcelWithState(parcel.pack(), 5000); assertEquals(ItemState.APPROVED, client.getState(simpleContract.getId()).state); mm.forEach(x -> x.shutdown()); } protected static final String ROOT_PATH = "./src/test_contracts/";
@Ignore @Test public void registerSimpleContractWithPayment() throws Exception { Contract contractToRegister = new Contract(TestKeys.privateKey(10)); contractToRegister.seal(); ItemResult itemResult = normalClient.register(contractToRegister.getPackedTransaction(), 5000); System.out.println("register... done! itemResult: " + itemResult.state); assertEquals(ItemState.UNDEFINED, itemResult.state); Parcel parcel = ContractsService.createParcel(contractToRegister, paymentContract, 1, Stream.of(paymentContractPrivKey).collect(Collectors.toSet()), true); normalClient.registerParcelWithState(parcel.pack(), 5000); itemResult = normalClient.getState(parcel.getPaymentContract().getId()); if (itemResult.state == ItemState.APPROVED) paymentContract = parcel.getPaymentContract(); System.out.println("registerParcel... done!"); System.out.println("parcel.paymentContract.itemResult: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = normalClient.getState(contractToRegister.getId()); System.out.println("contractToRegister.itemResult: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); }
public synchronized Parcel createParcelWithFreshU(Client client, Contract c, Collection<PrivateKey> keys) throws Exception { Set<PublicKey> ownerKeys = new HashSet(); keys.stream().forEach(key->ownerKeys.add(key.getPublicKey())); Contract stepaU = InnerContractsService.createFreshU(100000000, ownerKeys); stepaU.check(); stepaU.traceErrors(); PrivateKey clientPrivateKey = client.getSession().getPrivateKey(); PrivateKey newPrivateKey = new PrivateKey(Do.read("./src/test_contracts/keys/u_key.private.unikey")); client.getSession().setPrivateKey(newPrivateKey); client.restart(); ItemResult itemResult = client.register(stepaU.getPackedTransaction(), 5000); client.getSession().setPrivateKey(clientPrivateKey); client.restart(); assertEquals(ItemState.APPROVED, itemResult.state); Set<PrivateKey> keySet = new HashSet<>(); keySet.addAll(keys); return ContractsService.createParcel(c, stepaU, 150, keySet); }
@Test(timeout = 90000) public void declinePaymentAndPaymentWithChangedData() throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Contract uContract = getApprovedUContract(); Contract modifiedU = uContract.createRevision(stepaPrivateKeys); modifiedU.getStateData().set("transaction_units", modifiedU.getStateData().getIntOrThrow("transaction_units") - 1); modifiedU.seal(); // stepaPrivateKeys - is also U keys Parcel parcel = ContractsService.createParcel(modifiedU, uContract, 150, stepaPrivateKeys); System.out.println("-------------"); node.registerParcel(parcel); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } waitAndCheckState(parcel, ItemState.UNDEFINED); }
private void checkCreateParcelFotTestNet(String contract_file_payload, String contract_file_payment) throws Exception { final String ROOT_PATH = "./src/test_contracts/contractService/"; PrivateKey privateKey = TestKeys.privateKey(3); Set<PrivateKey> privateKeys = new HashSet<>(); privateKeys.add(privateKey); Set<PublicKey> publicKeys = new HashSet<>(); publicKeys.add(privateKey.getPublicKey()); Contract payload = Contract.fromDslFile(ROOT_PATH + contract_file_payload); payload.addSignerKey(privateKey); payload.seal(); Contract payment = InnerContractsService.createFreshU(100, publicKeys, true); Parcel parcel = ContractsService.createParcel(payload, payment, 20, privateKeys, true); assertEquals(parcel.getPayloadContract().getState().getBranchId(), payload.getState().getBranchId()); assertEquals(parcel.getPaymentContract().getState().getBranchId(), payment.getState().getBranchId()); assertEquals(parcel.getPayloadContract().getStateData(), payload.getStateData()); assertEquals(parcel.getPaymentContract().getDefinition().getData(), payment.getDefinition().getData()); assertEquals(100, parcel.getPaymentContract().getStateData().getIntOrThrow("transaction_units")); assertEquals(10000 - 20, parcel.getPaymentContract().getStateData().getIntOrThrow("test_transaction_units")); System.out.println("OK"); }
Parcel parcel = ContractsService.createParcel(stepaCoins, stepaU, 50, stepaPrivateKeys);
private void checkCreateParcel(String contract_file_payload, String contract_file_payment) throws Exception { final String ROOT_PATH = "./src/test_contracts/contractService/"; PrivateKey privateKey = TestKeys.privateKey(3); Contract payload = Contract.fromDslFile(ROOT_PATH + contract_file_payload); payload.addSignerKey(privateKey); payload.seal(); Contract payment = Contract.fromDslFile(ROOT_PATH + contract_file_payment); payment.addSignerKey(privateKey); payment.seal(); Set<PrivateKey> PrivateKeys = new HashSet<>(); PrivateKeys.add(privateKey); Parcel parcel = ContractsService.createParcel(payload, payment, 20, PrivateKeys); assertEquals(parcel.getPayloadContract().getState().getBranchId(), payload.getState().getBranchId()); assertEquals(parcel.getPaymentContract().getState().getBranchId(), payment.getState().getBranchId()); assertEquals(parcel.getPayloadContract().getStateData(), payload.getStateData()); assertEquals(parcel.getPaymentContract().getDefinition().getData(), payment.getDefinition().getData()); System.out.println("OK"); }
@Test(timeout = 90000) public void payForParcelWithLastU() 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 paidContract = new Contract(stepaPrivateKeys.iterator().next()); paidContract.seal(); paidContract.check(); paidContract.traceErrors(); // create 1 U Contract stepaU = InnerContractsService.createFreshU(1, stepaPublicKeys, true); stepaU.check(); stepaU.traceErrors(); node.registerItem(stepaU); ItemResult itemResult = node.waitItem(stepaU.getId(), 18000); assertEquals(ItemState.APPROVED, itemResult.state); assertEquals(stepaU.getStateData().getIntOrThrow("transaction_units"), 1); assertEquals(stepaU.getStateData().getIntOrThrow("test_transaction_units"), 100); // pay 1 U Parcel parcel = ContractsService.createParcel(paidContract, stepaU, 1, stepaPrivateKeys, false); node.registerParcel(parcel); node.waitParcel(parcel.getId(), 8000); // check zero U registered assertEquals(ItemState.APPROVED, node.waitItem(paidContract.getId(), 8000).state); assertEquals(ItemState.APPROVED, node.waitItem(parcel.getPaymentContract().getId(), 8000).state); assertEquals(parcel.getPaymentContract().getStateData().getIntOrThrow("transaction_units"), 0); assertEquals(parcel.getPaymentContract().getStateData().getIntOrThrow("test_transaction_units"), 100); }
assertEquals(ItemState.APPROVED, itemResult.state); Parcel parcel = ContractsService.createParcel(paidContract, stepaU, 1, stepaPrivateKeys, false); Contract payment = parcel.getPaymentContract(); Contract payload = parcel.getPayloadContract();