private void testIssueMultipleFullAssets()
throws CantDefineContractPropertyException, CantIssueDigitalAssetsException {
LOG.info("MAP_TEST_MULTIPLE_FULL_ASSETS");
DigitalAsset digitalAsset = new DigitalAsset();
digitalAsset.setPublicKey(new ECCKeyPair().getPublicKey());
digitalAsset.setDescription("Descripcion de prueba");
digitalAsset.setGenesisAddress(
new CryptoAddress("n1zVgphtAoxgDMUzKV5ATeggwvUwnssb7m", CryptoCurrency.BITCOIN));
digitalAsset.setGenesisAmount(1000);
List<Resource> resources = new ArrayList<>();
Resource resource = new Resource();
resource.setId(UUID.randomUUID());
resource.setName("Foto 1");
resource.setFileName("imagen2.png");
resource.setResourceType(ResourceType.IMAGE);
resource.setResourceDensity(ResourceDensity.HDPI);
resource.setResourceBinayData(
new byte[] {0xa, 0x2, 0xf, (byte) 0xff, (byte) 0xff, (byte) 0xff});
Resource resource2 = new Resource();
resource2.setId(UUID.randomUUID());
resource2.setName("Foto 1");
resource2.setFileName("imagen2.png");
resource2.setResourceType(ResourceType.IMAGE);
resource2.setResourceDensity(ResourceDensity.HDPI);
resource2.setResourceBinayData(
new byte[] {0xa, 0x2, 0xf, (byte) 0xff, (byte) 0xff, (byte) 0xff});
Resource resource3 = new Resource();
resource3.setId(UUID.randomUUID());
resource3.setName("Foto 1");
resource3.setFileName("imagen2.png");
resource3.setResourceType(ResourceType.IMAGE);
resource3.setResourceDensity(ResourceDensity.HDPI);
resource3.setResourceBinayData(
new byte[] {0xa, 0x2, 0xf, (byte) 0xff, (byte) 0xff, (byte) 0xff});
resources.add(resource);
resources.add(resource2);
resources.add(resource3);
digitalAsset.setResources(resources);
IdentityAssetIssuer identityAssetIssuer = new MockIdentityAssetIssuerForTest();
digitalAsset.setName("Asset de prueba");
digitalAsset.setIdentityAssetIssuer(identityAssetIssuer);
DigitalAssetContract contract = new DigitalAssetContract();
contract.setContractProperty(
new ContractProperty(DigitalAssetContractPropertiesConstants.REDEEMABLE, Boolean.TRUE));
digitalAsset.setContract(contract);
System.out.println(digitalAsset.toString());
this.assetIssuingTransactionManager.issueAssets(
digitalAsset, 10, "TESTING PUBLICKEY", BlockchainNetworkType.REG_TEST);
LOG.info("MAP_END_TEST_MULTIPLE_FULL_ASSETS");
}
private void testDigitalAssetMetadataVault()
throws CantCreateDigitalAssetFileException, CantGetDigitalAssetFromLocalStorageException {
Logger LOG = Logger.getGlobal();
LOG.info("MAP_TEST_DAMVault");
DigitalAsset digitalAsset = new DigitalAsset();
digitalAsset.setGenesisAmount(100000);
digitalAsset.setDescription("TestAsset");
digitalAsset.setName("testName");
digitalAsset.setPublicKey(new ECCKeyPair().getPublicKey());
LOG.info("MAP_DigitalAsset:" + digitalAsset);
List<Resource> resources = new ArrayList<>();
digitalAsset.setResources(resources);
digitalAsset.setIdentityAssetIssuer(null);
DigitalAssetContract digitalAssetContract = new DigitalAssetContract();
digitalAsset.setContract(digitalAssetContract);
LOG.info("MAP_DigitalAsset2:" + digitalAsset);
DigitalAssetMetadata dam = new DigitalAssetMetadata(digitalAsset);
dam.setGenesisTransaction("testGenesisTX");
this.digitalAssetIssuingVault.persistDigitalAssetMetadataInLocalStorage(dam, "testId");
LOG.info(
"DAM from vault:\n"
+ this.digitalAssetIssuingVault
.getDigitalAssetMetadataFromLocalStorage("testGenesisTX")
.toString());
}
public static boolean isDigitalAssetComplete(DigitalAssetMetadata digitalAssetMetadata) {
try {
DigitalAsset digitalAsset = digitalAssetMetadata.getDigitalAsset();
areObjectsSettled(digitalAsset);
CryptoAddress genesisAddress = digitalAsset.getGenesisAddress();
if (Validate.isObjectNull(genesisAddress)) {
return false;
}
String digitalAssetHash = digitalAssetMetadata.getDigitalAssetHash();
if (Validate.isValidString(digitalAssetHash)) {
return false;
}
return true;
} catch (ObjectNotSetException e) {
return false;
}
}
/**
* This method implement a delivering test to asset issuer wallet, mocking an event raise and
* transactions
*
* @throws CantDefineContractPropertyException
* @throws CantCreateDigitalAssetFileException
* @throws CantPersistDigitalAssetException
* @throws CantSetObjectException
* @throws CantExecuteQueryException
* @throws UnexpectedResultReturnedFromDatabaseException
* @throws CantPersistsGenesisTransactionException
* @throws CantCheckAssetIssuingProgressException
* @throws CantStartAgentException
* @throws CantGetLoggedInDeviceUserException
* @throws CantCreateFileException
* @throws CantPersistFileException
*/
private void testWalletDeliverAssetToAssetIssuerWallet()
throws CantDefineContractPropertyException, CantCreateDigitalAssetFileException,
CantPersistDigitalAssetException, CantSetObjectException, CantExecuteQueryException,
UnexpectedResultReturnedFromDatabaseException, CantPersistsGenesisTransactionException,
CantCheckAssetIssuingProgressException, CantStartAgentException,
CantGetLoggedInDeviceUserException, CantCreateFileException, CantPersistFileException,
CantPersistsTransactionUUIDException, CantPersistsGenesisAddressException {
printSomething("Start deliver to Asset wallet test");
String genesisTransaction = "d21633ba23f70118185227be58a63527675641ad37967e2aa461559f577aec43";
MockDigitalAssetMetadataForTesting mockDigitalAssetMetadataForTesting =
new MockDigitalAssetMetadataForTesting();
DigitalAsset mockDigitalAssetForTesting = mockDigitalAssetMetadataForTesting.getDigitalAsset();
String digitalAssetInnerXML = mockDigitalAssetForTesting.toString();
// PluginTextFile digitalAssetFile=this.pluginFileSystem.createTextFile(this.pluginId,
// "digital-asset-swap/", genesisTransaction+".xml", FilePrivacy.PUBLIC,
// FileLifeSpan.PERMANENT);
// digitalAssetFile.setContent(digitalAssetInnerXML);
// digitalAssetFile.persistToMedia();
this.digitalAssetIssuingVault.setWalletPublicKey("walletPublicKeyTest");
this.digitalAssetIssuingVault.persistDigitalAssetMetadataInLocalStorage(
mockDigitalAssetMetadataForTesting, "testId");
this.assetIssuingTransactionDao.persistDigitalAsset(
mockDigitalAssetForTesting.getPublicKey(),
"testLocalPath",
1,
BlockchainNetworkType.REG_TEST,
"testWalletPublicKey");
this.assetIssuingTransactionDao.persistDigitalAssetTransactionId(
mockDigitalAssetForTesting.getPublicKey(), "testId");
this.assetIssuingTransactionDao.persistDigitalAssetHash(
"testId", mockDigitalAssetMetadataForTesting.getDigitalAssetHash());
UUID mockUUId = UUID.randomUUID();
this.assetIssuingTransactionDao.persistOutgoingIntraActorUUID("testId", mockUUId);
this.assetIssuingTransactionDao.persistGenesisTransaction(
mockUUId.toString(), genesisTransaction);
this.assetIssuingTransactionDao.updateTransactionProtocolStatus(
genesisTransaction, ProtocolStatus.TO_BE_NOTIFIED);
this.assetIssuingTransactionDao.updateDigitalAssetTransactionStatus(
"testId", TransactionStatus.CRYPTO_SENT);
this.assetIssuingTransactionDao.updateDigitalAssetCryptoStatusByTransactionHash(
mockDigitalAssetMetadataForTesting.getDigitalAssetHash(), CryptoStatus.PENDING_SUBMIT);
testRaiseEvent();
startMonitorAgent();
printSomething("End Deliver test");
}
private void testIssueSingleAsset() throws CantIssueDigitalAssetsException {
Logger LOG = Logger.getGlobal();
LOG.info("MAP_TEST_SINGLE");
DigitalAsset digitalAsset = new DigitalAsset();
digitalAsset.setGenesisAmount(100000);
digitalAsset.setDescription("TestAsset");
digitalAsset.setName("testName");
digitalAsset.setPublicKey(new ECCKeyPair().getPublicKey());
LOG.info("MAP_DigitalAsset:" + digitalAsset);
List<Resource> resources = new ArrayList<>();
digitalAsset.setResources(resources);
digitalAsset.setIdentityAssetIssuer(null);
DigitalAssetContract digitalAssetContract = new DigitalAssetContract();
digitalAsset.setContract(digitalAssetContract);
LOG.info("MAP_DigitalAsset2:" + digitalAsset);
this.issueAssets(
digitalAsset, 1, new ECCKeyPair().getPublicKey(), BlockchainNetworkType.REG_TEST);
}
/**
* This method checks that every object in Digital asset is set.
*
* @throws ObjectNotSetException
*/
public static void areObjectsSettled(DigitalAsset digitalAsset) throws ObjectNotSetException {
if (digitalAsset.getContract() == null) {
throw new ObjectNotSetException("Digital Asset Contract is not set");
}
if (digitalAsset.getResources() == null) {
throw new ObjectNotSetException("Digital Asset Resources is not set");
}
if (digitalAsset.getDescription() == null) {
throw new ObjectNotSetException("Digital Asset Description is not set");
}
if (digitalAsset.getName() == null) {
throw new ObjectNotSetException("Digital Asset Name is not set");
}
if (digitalAsset.getPublicKey() == null) {
throw new ObjectNotSetException("Digital Asset PublicKey is not set");
}
if (digitalAsset.getState() == null) {
digitalAsset.setState(State.DRAFT);
}
if (digitalAsset.getIdentityAssetIssuer() == null) {
throw new ObjectNotSetException("Digital Asset Identity is not set");
}
}
@Before
public void setUp() throws Exception {
pluginId = UUID.randomUUID();
assetIssuingPluginRoot = new AssetIssuingDigitalAssetTransactionPluginRoot();
assetIssuingPluginRoot.setId(pluginId);
assetIssuingPluginRoot.setErrorManager(errorManager);
assetIssuingPluginRoot.setLogManager(logManager);
assetIssuingPluginRoot.setEventManager(eventManager);
assetIssuingPluginRoot.setPluginDatabaseSystem(pluginDatabaseSystem);
assetIssuingPluginRoot.setPluginFileSystem(pluginFileSystem);
assetIssuingPluginRoot.setAssetIssuerManager(assetIssuerWalletManager);
assetIssuingPluginRoot.setActorAssetIssuerManager(actorAssetIssuerManager);
assetIssuingPluginRoot.setCryptoVaultManager(cryptoVaultManager);
assetIssuingPluginRoot.setBitcoinWalletManager(bitcoinWalletManager);
assetIssuingPluginRoot.setAssetVaultManager(assetVaultManager);
assetIssuingPluginRoot.setCryptoAddressBookManager(cryptoAddressBookManager);
assetIssuingPluginRoot.setOutgoingIntraActorManager(outgoingIntraActorManager);
assetIssuingPluginRoot.setDeviceUserManager(deviceUserManager);
assetIssuingPluginRoot.setBitcoinNetworkManager(bitcoinNetworkManager);
resources = new LinkedList<>();
digitalAsset = new DigitalAsset();
digitalAsset.setContract(digitalAssetContract);
digitalAsset.setResources(resources);
digitalAsset.setDescription(description);
digitalAsset.setName(name);
digitalAsset.setPublicKey(publicKey);
digitalAsset.setState(state);
digitalAsset.setIdentityAssetIssuer(identityAssetIssuer);
records = new LinkedList<>();
// records.add(mockDatabaseTableRecord);
setUpMockitoRules();
}
/** This method will deliver the DigitalAssetMetadata to ActorAssetUser */
private void deliverDigitalAssetToRemoteDevice(
DigitalAssetMetadata digitalAssetMetadata, ActorAssetUser actorAssetUser)
throws CantDeliverDigitalAssetException {
try {
// First, I going to persist in database the basic information about digitalAssetMetadata
System.out.println("ASSET DISTRIBUTION begins for " + actorAssetUser.getActorPublicKey());
persistDigitalAsset(digitalAssetMetadata, actorAssetUser);
System.out.println("ASSET DISTRIBUTION begins for persisted");
// Now, I'll check is Hash wasn't modified
// checkDigitalAssetMetadata(digitalAssetMetadata);
DigitalAsset digitalAsset = digitalAssetMetadata.getDigitalAsset();
System.out.println(
"ASSET DISTRIBUTION Digital Asset genesis address: " + digitalAsset.getGenesisAddress());
String genesisTransaction = digitalAssetMetadata.getGenesisTransaction();
System.out.println("ASSET DISTRIBUTION Genesis transaction:" + genesisTransaction);
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.CHECKING_AVAILABLE_BALANCE, genesisTransaction);
if (!isAvailableBalanceInAssetVault(digitalAsset.getGenesisAmount(), genesisTransaction)) {
System.out.println(
"ASSET DISTRIBUTION The Available balance in asset vault is insufficient - genesisAmount:"
+ digitalAsset.getGenesisAmount());
throw new CantDeliverDigitalAssetException(
"The Available balance in asset vault is incorrect");
}
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.AVAILABLE_BALANCE_CHECKED, genesisTransaction);
DigitalAssetContract digitalAssetContract = digitalAsset.getContract();
System.out.println("ASSET DISTRIBUTION Digital Asset contract: " + digitalAssetContract);
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.CHECKING_CONTRACT, genesisTransaction);
if (!isValidContract(digitalAssetContract)) {
System.out.println("ASSET DISTRIBUTION The contract is not valid");
throw new CantDeliverDigitalAssetException(
"The DigitalAsset Contract is not valid, the expiration date has passed");
}
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.CONTRACT_CHECKED, genesisTransaction);
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.CHECKING_HASH, genesisTransaction);
if (!isDigitalAssetHashValid(digitalAssetMetadata)) {
System.out.println("ASSET DISTRIBUTION The DAM Hash is not valid");
throw new CantDeliverDigitalAssetException("The DigitalAsset hash is not valid");
}
this.assetDistributionDao.updateDistributionStatusByGenesisTransaction(
DistributionStatus.HASH_CHECKED, genesisTransaction);
System.out.println(
"ASSET DISTRIBUTION set debit in asset issuer wallet:" + genesisTransaction);
digitalAssetDistributionVault.setDigitalAssetMetadataAssetIssuerWalletDebit(
digitalAssetMetadata, this.cryptoTransaction, BalanceType.AVAILABLE);
System.out.println("ASSET DISTRIBUTION Begins the deliver to an remote actor");
deliverToRemoteActor(digitalAssetMetadata, actorAssetUser);
} catch (CantPersistDigitalAssetException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Cannot persist digital asset into database");
} catch (CantCreateDigitalAssetFileException exception) {
throw new CantDeliverDigitalAssetException(
exception,
"Delivering digital assets",
"Cannot persist digital asset into local storage");
} catch (CantGetCryptoTransactionException exception) {
throw new CantDeliverDigitalAssetException(
exception,
"Delivering digital assets",
"Cannot get the genesisTransaction from Asset Vault");
} catch (CantExecuteQueryException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Cannot execute a database operation");
} catch (UnexpectedResultReturnedFromDatabaseException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Unexpected result in database");
} catch (CantSendDigitalAssetMetadataException exception) {
throw new CantDeliverDigitalAssetException(
exception,
"Delivering digital assets",
"There is an error delivering the digital asset through the network layer");
} catch (DAPException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Generic DAP Exception");
} catch (CantGetTransactionsException exception) {
throw new CantDeliverDigitalAssetException(
exception,
"Delivering digital assets",
"Cannot get the genesis transaction from crypto network");
} catch (CantLoadWalletException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Cannot load Asset issuer wallet");
} catch (CantRegisterDebitException exception) {
throw new CantDeliverDigitalAssetException(
exception, "Delivering digital assets", "Cannot register a debit in Asset Issuer Wallet");
}
}
