How to use

registerParcelWithState

method

in

com.icodici.universa.node2.network.Client

/**
 * Register contract on the network with parcel (includes payment)
 * @param packed {@link Parcel} binary
 * @param millisToWait maximum time to wait for final {@link ItemState}
 * @return result of registration
 * @throws ClientError
 */
@Deprecated
public boolean registerParcel(byte[] packed, long millisToWait) throws ClientError {
  try {
    registerParcelWithState(packed, millisToWait);
    return true;
  } catch (ClientError e) {
    if (e.getErrorRecord().getError() == Errors.COMMAND_PENDING)
      return true;
    else
      return false;
  }
}

/**
 * Register contract on the network with parcel (includes payment)
 * @param packed {@link Parcel} binary
 * @return result of registration
 * @throws ClientError
 */
public boolean registerParcel(byte[] packed) throws ClientError {
  try {
    registerParcelWithState(packed, 0);
    return true;
  } catch (ClientError e) {
    if (e.getErrorRecord().getError() == Errors.COMMAND_PENDING)
      return true;
    else
      return false;
  }
}

/**
 * Register packed binary contract and wait for the consensus.
 *
 * @param packedParcel
 * @param millisToWait wait for the consensus as long as specified time, <= 0 means no wait (returns some pending
 *                     state from registering).
 * @return last item status returned by the network
 * @throws ClientError
 */
public boolean registerParcel(byte[] packedParcel, long millisToWait) throws ClientError {
  try {
    client.registerParcelWithState(packedParcel, millisToWait);
    return true;
  } catch (ClientError e) {
    if (e.getErrorRecord().getError() == Errors.COMMAND_PENDING)
      return true;
    else
      return false;
  }
}

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;
}

protected synchronized Parcel registerWithNewParcel(Contract c) throws Exception {
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  Parcel parcel = createParcelWithClassU(c, stepaPrivateKeys);
  System.out.println("register  parcel: " + parcel.getId() + " " + parcel.getPaymentContract().getId() + " " + parcel.getPayloadContract().getId());
  normalClient.registerParcelWithState(parcel.pack(),8000);
  synchronized (uContractLock) {
    uContract = parcel.getPaymentContract();
  }
  return parcel;
}

assertTrue(testContract.isOk());
Parcel parcel = createParcelWithFreshU(ts.client, testContract, Do.listOf(ts.myKey));
ts.client.registerParcelWithState(parcel.pack(), 18000);

@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);
}

@Test
public void checkWhiteListKey() throws Exception {
  List<Main> mm = new ArrayList<>();
  for (int i = 0; i < 3; i++) {
    mm.add(createMain("node" + (i + 1), false));
  }
  Main main = mm.get(0);
  PrivateKey myKey = TestKeys.privateKey(3);
  Client client = null;
  try {
    client = new Client(myKey, main.myInfo, null);
  } catch (Exception e) {
    System.out.println("prepareClient exception: " + e.toString());
  }
  Contract testContract = new Contract(myKey);
  for (int i = 0; i < 10; i++) {
    Contract nc = new Contract(myKey);
    nc.seal();
    testContract.addNewItems(nc);
  }
  testContract.seal();
  assertTrue(testContract.isOk());
  Parcel parcel = createParcelWithFreshU(client, testContract,Do.listOf(myKey));
  ItemResult itemResult = client.registerParcelWithState(parcel.pack(), 15000);
  System.out.println(">> state: " + itemResult);
  assertEquals (ItemState.APPROVED, itemResult.state);
  mm.forEach(x -> x.shutdown());
}

client.registerParcelWithState(parcel.pack(),60000);
ItemResult rr;
while(true) {

client.registerParcelWithState(parcel.pack(),15000);
client.registerParcelWithState(parcel.pack(),15000);
while (true) {
client.registerParcelWithState(parcel.pack(),15000);
while (true) {

assertTrue(testContract.isOk());
Parcel parcel = createParcelWithFreshU(client, testContract,Do.listOf(myKey));
client.registerParcelWithState(parcel.pack(), 5000);
System.out.println(">> before shutdown state: " + client.getState(parcel.getPayloadContract().getId()));
System.out.println(">> before shutdown state: " + client.getState(parcel.getPayloadContract().getNew().get(0).getId()));

assertEquals(false, Arrays.equals(simpleContract.getPackedTransaction(), simpleContractBytes));
client.registerParcelWithState(parcel.pack(), 5000);
itemResult = client.getState(slotContract.getId());
System.out.println("slot : " + itemResult);

keySet.addAll(keys);
Parcel parcel = ContractsService.createParcel(testContract, stepaU, 150, keySet);
client.registerParcelWithState(parcel.pack(), 15000);

keySet.addAll(keys);
Parcel parcel = ContractsService.createParcel(testContract, stepaU, 150, keySet);
client.registerParcelWithState(parcel.pack(), 15000);

assertTrue(testContract.isOk());
Parcel parcel = createParcelWithFreshU(client, testContract,Do.listOf(myKey));
client.registerParcelWithState(parcel.pack(), 1000);
ItemResult itemResult = client.getState(parcel.getPayloadContract().getId());
assertTrue(testContract2.isOk());
Parcel parcel2 = createParcelWithFreshU(client, testContract2,Do.listOf(myKey));
client.registerParcelWithState(parcel2.pack(), 1000);
ItemResult itemResult2 = client.getState(parcel2.getPayloadContract().getId());
assertTrue(testContract3.isOk());
Parcel parcel3 = createParcelWithFreshU(client, testContract3,Do.listOf(myKey));
client.registerParcelWithState(parcel3.pack(), 1000);
ItemResult itemResult3 = client.getState(parcel3.getPayloadContract().getId());

assertTrue(testContract.isOk());
Parcel parcel = createParcelWithFreshU(client, testContract,Do.listOf(myKey));
client.registerParcelWithState(parcel.pack(), 1000);
ItemResult itemResult = client.getState(parcel.getPayloadContract().getId());
assertTrue(testContract2.isOk());
Parcel parcel2 = createParcelWithFreshU(client, testContract2,Do.listOf(myKey));
client.registerParcelWithState(parcel2.pack(), 1000);
ItemResult itemResult2 = client.getState(parcel2.getPayloadContract().getId());
assertTrue(testContract4.isOk());
Parcel parcel4 = createParcelWithFreshU(client, testContract4,Do.listOf(myKey));
client.registerParcelWithState(parcel4.pack(), 1000);
ItemResult itemResult4 = client.getState(parcel4.getPayloadContract().getId());
assertTrue(testContract3.isOk());
Parcel parcel3 = createParcelWithFreshU(client, testContract3,Do.listOf(myKey));
client.registerParcelWithState(parcel3.pack(), 1000);
ItemResult itemResult3 = client.getState(parcel3.getPayloadContract().getId());

client.registerParcelWithState(parcel.pack(), 8000);
client.registerParcelWithState(parcel.pack(), 8000);
client.registerParcelWithState(parcel.pack(), 8000);

client.registerParcelWithState(parcel.pack(), 8000);
client.registerParcelWithState(parcel.pack(), 8000);
client.registerParcelWithState(parcel.pack(), 8000);