org.iota.jota

Class IotaAPI

java.lang.Object

org.iota.jota.IotaAPICore

org.iota.jota.IotaAPI

public class IotaAPI
extends IotaAPICore

IotaAPI Builder. Usage:

IotaAPI api = new IotaAPI.Builder() .protocol("http") .nodeAddress("localhost") .port(12345) .build(); GetNodeInfoResponse response = api.getNodeInfo();

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	IotaAPI.Builder

Field Summary

Fields inherited from class org.iota.jota.IotaAPICore

nodes

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	IotaAPI(ApiOptions options)
protected	IotaAPI(IotaAPI.Builder builder)

Method Summary

Modifier and Type	Method and Description
List<String>	addRemainder(String seed, int security, List<Input> inputs, Bundle bundle, String tag, long totalValue, String remainderAddress, List<String> signatureFragments) Uses input, and adds to the bundle, untill totalValue is reached.
Bundle[]	bundlesFromAddresses(Boolean inclusionStates, String... addresses) Internal function to get the formatted bundles of a list of addresses.
boolean[]	checkWereAddressSpentFrom(String... addresses) Check if a list of addresses was ever spent from, in the current epoch, or in previous epochs.
Boolean	checkWereAddressSpentFrom(String address) Check if an addresses was ever spent from, in the current epoch, or in previous epochs.
List<Transaction>	findTransactionObjectsByAddresses(String[] addresses) Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.
List<Transaction>	findTransactionObjectsByApprovees(String... approvees) Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.
List<Transaction>	findTransactionObjectsByBundle(String... bundles) Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.
List<Transaction>	findTransactionObjectsByTag(String... tags) Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.
List<Transaction>	findTransactionsObjectsByHashes(String... hashes) Wrapper function: get trytes and turns into Transaction objects.
GetNewAddressResponse	generateNewAddresses(AddressRequest addressRequest) Generates new addresses, meaning addresses which were not spend from, according to the connected node.
GetAccountDataResponse	getAccountData(String seed, int security, int index, boolean checksum, int total, boolean returnAll, int start, int end, boolean inclusionStates, long threshold) Similar to getTransfers, just that it returns additional account data
GetNewAddressResponse	getAddressesUnchecked(AddressRequest addressRequest) Generates amount of addresses, starting from index This does not mean that these addresses are safe to use (unspent)
long	getBalance(int threshold, String address) The returned balance is based on the latest confirmed milestone.
GetBalancesAndFormatResponse	getBalanceAndFormat(List<String> addresses, List<String> tips, long threshold, int start, StopWatch stopWatch, int security) Gets the balances and formats the output.
GetBundleResponse	getBundle(String transaction) Gets the associated bundle transactions of a single transaction.
GetBalancesAndFormatResponse	getInputs(String seed, int security, int start, int end, long threshold, String... tips) Gets the inputs of a seed If start, end and threshold are 0, checks everything until an address with nothing is found.
GetInclusionStateResponse	getLatestInclusion(String... hashes) Wrapper function: runs getNodeInfo and getInclusionStates Uses the latest milestone as tip
GetTransferResponse	getTransfers(String seed, int security, Integer start, Integer end, Boolean inclusionStates) Finds all the bundles for all the addresses based on this seed and security.
List<Transaction>	initiateTransfer(int securitySum, String inputAddress, String remainderAddress, List<Transfer> transfers) Prepares transfer by generating the bundle with the corresponding cosigner transactions.
List<Transaction>	initiateTransfer(int securitySum, String inputAddress, String remainderAddress, List<Transfer> transfers, boolean testMode) Prepares transfer by generating the bundle with the corresponding cosigner transactions.
List<Transaction>	initiateTransfer(int securitySum, String inputAddress, String remainderAddress, List<Transfer> transfers, List<Transaction> tips) Prepares transfer by generating the bundle with the corresponding cosigner transactions.
List<Transaction>	initiateTransfer(int securitySum, String inputAddress, String remainderAddress, List<Transfer> transfers, List<Transaction> tips, boolean testMode) Prepares transfer by generating the bundle with the corresponding cosigner transactions.
boolean	isPromotable(String tail) Checks if a transaction hash is promotable
boolean	isPromotable(Transaction tail) Checks if a transaction hash is promotable
List<String>	prepareTransfers(String seed, int security, List<Transfer> transfers, String remainder, List<Input> inputs, List<Transaction> tips, boolean validateInputs) Prepares transfer by generating bundle, finding and signing inputs.
List<Transaction>	promoteTransaction(String tail, int depth, int minWeightMagnitude, Bundle bundle) Attempts to promote a transaction using a provided bundle and, if successful, returns the promoting Transactions.
ReplayBundleResponse	replayBundle(Bundle bundle, int depth, int minWeightMagnitude, String reference) Replays a transfer by doing Proof of Work again.
ReplayBundleResponse	replayBundle(String tailTransactionHash, int depth, int minWeightMagnitude, String reference) Replays a transfer by doing Proof of Work again.
SendTransferResponse	sendTransfer(String seed, int security, int depth, int minWeightMagnitude, List<Transfer> transfers, List<Input> inputs, String remainderAddress, boolean validateInputs, boolean validateInputAddresses, List<Transaction> tips) Wrapper function: Runs prepareTransfers, as well as attachToTangle.
List<Transaction>	sendTrytes(String[] trytes, int depth, int minWeightMagnitude, String reference) Wrapper method: Gets transactions to approve, attaches to Tangle, broadcasts and stores.
BroadcastTransactionsResponse	storeAndBroadcast(String... trytes) Wrapper method: stores and broadcasts the specified trytes.
Bundle	traverseBundle(String trunkTx, String bundleHash, Bundle bundle) Traverses the Bundle by going down the trunkTransactions until the bundle hash of the transaction changes.
void	validateTransfersAddresses(String seed, int security, List<String> trytes) Validates the supplied transactions with seed and security.

Methods inherited from class org.iota.jota.IotaAPICore

addNeighbors, addNode, attachToTangle, attachToTangleLocalPow, broadcastTransactions, callIxi, checkConsistency, findTransactions, findTransactionsByAddresses, findTransactionsByApprovees, findTransactionsByBundles, findTransactionsByDigests, findTransactionsByTags, getBalances, getBalances, getBalances, getCurl, getHost, getInclusionStates, getLocalPoW, getNeighbors, getNodeInfo, getNodes, getPort, getProtocol, getRandomNode, getTips, getTransactionsToApprove, getTransactionsToApprove, getTrytes, hasNodes, interruptAttachingToTangle, removeNeighbors, removeNode, setCurl, setLocalPoW, storeTransactions, toString, wereAddressesSpentFrom

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

IotaAPI

protected IotaAPI(ApiOptions options)

IotaAPI

protected IotaAPI(IotaAPI.Builder builder)

Method Detail

generateNewAddresses

public GetNewAddressResponse generateNewAddresses(AddressRequest addressRequest)

Generates new addresses, meaning addresses which were not spend from, according to the connected node. Stops when AddressRequest.getAmount() of unspent addresses are found, starting from AddressRequest.getIndex() If AddressRequest.getAmount() is set to 0, we will generate until the first unspent address is found, and stop.

Parameters:

addressRequest - AddressRequest

Returns:

GetNewAddressResponse

getAddressesUnchecked

public GetNewAddressResponse getAddressesUnchecked(AddressRequest addressRequest)
                                            throws ArgumentException

Generates amount of addresses, starting from index This does not mean that these addresses are safe to use (unspent)

Parameters:

addressRequest - AddressRequest

Returns:

GetNewAddressResponse

Throws:

ArgumentException - is thrown when the specified input is not valid.

getTransfers

public GetTransferResponse getTransfers(String seed,
                                        int security,
                                        Integer start,
                                        Integer end,
                                        Boolean inclusionStates)
                                 throws ArgumentException

Finds all the bundles for all the addresses based on this seed and security.

Parameters:

seed - Tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

start - Starting key index, must be at least 0.

end - Ending key index, must be bigger then start

inclusionStates - If true, it also gets the inclusion states of the transfers.

Returns:

GetTransferResponse

Throws:

ArgumentException - when start and end are more then 500 apart

ArgumentException - Invalid security index

IllegalStateException - When the seed is invalid

bundlesFromAddresses

public Bundle[] bundlesFromAddresses(Boolean inclusionStates,
                                     String... addresses)
                              throws ArgumentException

Internal function to get the formatted bundles of a list of addresses.

Parameters:

addresses - If true, it also gets the inclusion state of each bundle.

inclusionStates - Array of addresses.

Returns:

All the transaction bundles for the addresses, or null when our thread gets interrupted

Throws:

ArgumentException - When the addresses are invalid

IllegalStateException - When inclusion state/confirmed could not be determined (null returned)

storeAndBroadcast

public BroadcastTransactionsResponse storeAndBroadcast(String... trytes)
                                                throws ArgumentException

Wrapper method: stores and broadcasts the specified trytes.

Parameters:

trytes - The trytes.

Returns:

BroadcastTransactionsResponse

Throws:

ArgumentException - is thrown when the specified trytes is not valid.

ArgumentException - If IotaAPICore.storeTransactions(String...) fails

See Also:

IotaAPICore.storeTransactions(String...), IotaAPICore.broadcastTransactions(String...)

sendTrytes

public List<Transaction> sendTrytes(String[] trytes,
                                    int depth,
                                    int minWeightMagnitude,
                                    String reference)
                             throws ArgumentException

Wrapper method: Gets transactions to approve, attaches to Tangle, broadcasts and stores.

Parameters:

trytes - The transaction trytes

depth - The depth for getting transactions to approve

minWeightMagnitude - The minimum weight magnitude for doing proof of work

reference - Hash of transaction to start random-walk from This is used to make sure the tips returned reference a given transaction in their past. This can be null, in that case the latest milestone is used as a reference.

Returns:

Sent Transaction objects.

Throws:

ArgumentException - is thrown when invalid trytes is provided.

See Also:

IotaAPICore.broadcastTransactions(String...), IotaAPICore.attachToTangle(String, String, Integer, String...), storeAndBroadcast(String...)

findTransactionsObjectsByHashes

public List<Transaction> findTransactionsObjectsByHashes(String... hashes)
                                                  throws ArgumentException

Wrapper function: get trytes and turns into Transaction objects. Gets the trytes and transaction object from a list of transaction hashes.

Parameters:

hashes - The hashes of the transactions we want to get the transactions from

Returns:

Transaction objects.

Throws:

ArgumentException - if hashes is not a valid array of hashes

See Also:

IotaAPICore.getTrytes(String...)

findTransactionObjectsByAddresses

public List<Transaction> findTransactionObjectsByAddresses(String[] addresses)
                                                    throws ArgumentException

Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.

Parameters:

addresses - The addresses we should get the transactions for, must contain checksums

Returns:

a list of Transaction objects.

Throws:

ArgumentException - if addresses is not a valid array of hashes

See Also:

IotaAPICore.findTransactionsByAddresses(String...), findTransactionsObjectsByHashes(java.lang.String...)

findTransactionObjectsByTag

public List<Transaction> findTransactionObjectsByTag(String... tags)
                                              throws ArgumentException

Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.

Parameters:

tags - The tags the transactions we search for have

Returns:

a list of Transaction objects.

Throws:

ArgumentException - if any of the tags are not a valid

See Also:

IotaAPICore.findTransactionsByTags(String...), findTransactionsObjectsByHashes(java.lang.String...)

findTransactionObjectsByApprovees

public List<Transaction> findTransactionObjectsByApprovees(String... approvees)
                                                    throws ArgumentException

Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.

Parameters:

approvees - The transaction hashes of which we want to approvers

Returns:

Transaction objects.

Throws:

ArgumentException - if addresses is not a valid array of hashes

See Also:

IotaAPICore.findTransactionsByApprovees(java.lang.String...)

findTransactionObjectsByBundle

public List<Transaction> findTransactionObjectsByBundle(String... bundles)
                                                 throws ArgumentException

Wrapper function: Finds transactions, gets trytes and turns it into Transaction objects.

Parameters:

bundles - The bundles for which we will get all its transactions

Returns:

Transaction objects.

Throws:

ArgumentException - if addresses is not a valid array of hashes

See Also:

IotaAPICore.findTransactionsByBundles(java.lang.String...)

prepareTransfers

public List<String> prepareTransfers(String seed,
                                     int security,
                                     List<Transfer> transfers,
                                     String remainder,
                                     List<Input> inputs,
                                     List<Transaction> tips,
                                     boolean validateInputs)
                              throws ArgumentException

Prepares transfer by generating bundle, finding and signing inputs.

Parameters:

seed - The tryte-encoded seed. It should be noted that this seed is not transferred. Only required when we are preparing a value transfer

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

transfers - List of transfer objects. If the total value of the transfers is 0, no signing is performed.

remainder - If defined, this address will be used for sending the remainder value (of the inputs) to. Otherwise, then next available address is used (if the transfer value is over 0)

inputs - The inputs used for this transfer

tips - The starting points we walk back from to find the balance of the addresses, can be null

validateInputs - Whether or not to validate the balances of the provided inputs If no validation is required

Returns:

Returns a list of the trytes of each bundle.

Throws:

ArgumentException - If the seed is invalid

ArgumentException - If the security level is wrong.

IllegalStateException - If the transfers are not all valid

IllegalStateException - If there is not enough balance in the inputs

getInputs

public GetBalancesAndFormatResponse getInputs(String seed,
                                              int security,
                                              int start,
                                              int end,
                                              long threshold,
                                              String... tips)
                                       throws ArgumentException

Gets the inputs of a seed If start, end and threshold are 0, checks everything until an address with nothing is found. Addresses are all with checksum appended

Parameters:

seed - Tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

start - Starting key index, must be at least 0.

end - Ending key index, must be bigger then start, and cant span more than 500 indexes

threshold - Minimum balance required.

tips - The starting points we walk back from to find the balance of the addresses, can be null

Returns:

GetBalancesAndFormatResponse

Throws:

ArgumentException - If the seed is invalid

ArgumentException - If the security level is wrong.

ArgumentException - when start and end are more then 500 apart

See Also:

getBalanceAndFormat(List, List, long, int, StopWatch, int)

getBalance

public long getBalance(int threshold,
                       String address)
                throws ArgumentException

The returned balance is based on the latest confirmed milestone. In addition to the balances, it also returns the referencing tips (or milestone), as well as the index with which the confirmed balance was determined. The balances are returned as a list in the same order as the addresses were provided as input.

Parameters:

threshold - The confirmation threshold between 0 and 100(inclusive). Should be set to 100 for getting balance by counting only confirmed transactions.

address - The addresses where we will find the balance for.

Returns:

GetBalancesResponse

Throws:

ArgumentException - The the request was considered wrong in any way by the node

getBalanceAndFormat

public GetBalancesAndFormatResponse getBalanceAndFormat(List<String> addresses,
                                                        List<String> tips,
                                                        long threshold,
                                                        int start,
                                                        StopWatch stopWatch,
                                                        int security)
                                                 throws ArgumentException,
                                                        IllegalStateException

Gets the balances and formats the output.

Parameters:

addresses - The addresses.

tips - The starting points we walk back from to find the balance of the addresses, can be null

threshold - Min balance required.

start - Starting key index.

stopWatch - the stopwatch. If you pass null, a new one is created.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

Returns:

GetBalancesAndFormatResponse

Throws:

ArgumentException - is thrown when the specified security level is not valid.

IllegalStateException - when there is not enough balance on the addresses

getBundle

public GetBundleResponse getBundle(String transaction)
                            throws ArgumentException

Gets the associated bundle transactions of a single transaction. Does validation of signatures, total sum as well as bundle order.

Parameters:

transaction - The transaction hash

Returns:

GetBundleResponse

Throws:

ArgumentException - if the transaction hash is invalid

ArgumentException - if the bundle is invalid or not found

getAccountData

public GetAccountDataResponse getAccountData(String seed,
                                             int security,
                                             int index,
                                             boolean checksum,
                                             int total,
                                             boolean returnAll,
                                             int start,
                                             int end,
                                             boolean inclusionStates,
                                             long threshold)
                                      throws ArgumentException

Similar to getTransfers, just that it returns additional account data

Parameters:

seed - Tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

index - Key index to start search from. If the index is provided, the generation of the address is not deterministic.

checksum - Adds 9-tryte address checksum. Checksum is required for all API calls.

total - Total number of addresses to generate.

returnAll - If true, it returns all addresses which were deterministically generated (until findTransactions returns null).

start - Starting key index, must be at least 0.

end - Ending key index, must be bigger then start

inclusionStates - If true, it gets the inclusion states of the transfers.

threshold - Minimum balance required.

Returns:

GetAccountDataResponse

Throws:

ArgumentException - when the specified security level is not valid.

ArgumentException - when start and end are invalid

See Also:

getTransfers(String, int, Integer, Integer, Boolean)

checkWereAddressSpentFrom

public boolean[] checkWereAddressSpentFrom(String... addresses)
                                    throws ArgumentException

Check if a list of addresses was ever spent from, in the current epoch, or in previous epochs. Addresses must have a checksum.

Parameters:

addresses - the addresses to check

Returns:

list of address boolean checks

Throws:

ArgumentException - when an address is invalid

checkWereAddressSpentFrom

public Boolean checkWereAddressSpentFrom(String address)
                                  throws ArgumentException

Check if an addresses was ever spent from, in the current epoch, or in previous epochs. Address must have a checksum.

Parameters:

address - the address to check

Returns:

true if it was spent, otherwise false

Throws:

ArgumentException - when the address is invalid

replayBundle

public ReplayBundleResponse replayBundle(String tailTransactionHash,
                                         int depth,
                                         int minWeightMagnitude,
                                         String reference)
                                  throws ArgumentException

Replays a transfer by doing Proof of Work again. This will make a new, but identical transaction which now also can be approved. If any of the replayed transactions gets approved, the others stop getting approved.

Parameters:

tailTransactionHash - The hash of tail transaction.

depth - The depth for getting transactions to approve

minWeightMagnitude - The minimum weight magnitude for doing proof of work

reference - Hash of transaction to start random-walk from. This is used to make sure the tips returned reference a given transaction in their past. Can be null, in that case the latest milestone is used as a reference.

Returns:

ReplayBundleResponse

Throws:

ArgumentException - when the tailTransactionHash is invalid

ArgumentException - when the bundle is invalid or not found

See Also:

sendTrytes(String[], int, int, String)

replayBundle

public ReplayBundleResponse replayBundle(Bundle bundle,
                                         int depth,
                                         int minWeightMagnitude,
                                         String reference)
                                  throws ArgumentException

Replays a transfer by doing Proof of Work again. This will make a new, but identical transaction which now also can be approved. If any of the replayed transactions gets approved, the others stop getting approved.

Parameters:

bundle - The bundle we wish to replay on the network

depth - The depth for getting transactions to approve

minWeightMagnitude - The minimum weight magnitude for doing proof of work

reference - Hash of transaction to start random-walk from. This is used to make sure the tips returned reference a given transaction in their past. Can be null, in that case the latest milestone is used as a reference.

Returns:

ReplayBundleResponse

Throws:

ArgumentException - when the tailTransactionHash is invalid

ArgumentException - when the bundle is invalid or not found

See Also:

sendTrytes(String[], int, int, String)

getLatestInclusion

public GetInclusionStateResponse getLatestInclusion(String... hashes)
                                             throws ArgumentException

Wrapper function: runs getNodeInfo and getInclusionStates Uses the latest milestone as tip

Parameters:

hashes - The hashes.

Returns:

GetInclusionStateResponse

Throws:

ArgumentException - when one of the hashes is invalid

See Also:

IotaAPICore.getNodeInfo(), IotaAPICore.getInclusionStates(String[], String[])

sendTransfer

public SendTransferResponse sendTransfer(String seed,
                                         int security,
                                         int depth,
                                         int minWeightMagnitude,
                                         List<Transfer> transfers,
                                         List<Input> inputs,
                                         String remainderAddress,
                                         boolean validateInputs,
                                         boolean validateInputAddresses,
                                         List<Transaction> tips)
                                  throws ArgumentException

Wrapper function: Runs prepareTransfers, as well as attachToTangle. We then broadcasts this and and store the transactions on the node.

Parameters:

seed - The tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

depth - The depth for getting transactions to approve

minWeightMagnitude - The minimum weight magnitude for doing proof of work

transfers - List of Transfer objects.

inputs - List of Input used for funding the transfer.

remainderAddress - If defined, this remainderAddress will be used for sending the remainder value (of the inputs) to. When this is not defined, but a remaining exists, the next free address is used.

validateInputs - Whether or not to validate the balances of the provided inputs.

validateInputAddresses - Whether or not to validate if the destination address is already use. If a key reuse is detect or it's send to inputs.

tips - The starting points we walk back from to find the balance of the addresses If multiple tips are supplied, only the first tip is used for IotaAPICore.getTransactionsToApprove(Integer, String)

Returns:

SendTransferResponse

Throws:

ArgumentException - If the seed is invalid

ArgumentException - If the security level is wrong.

ArgumentException - When validateInputAddresses is true, if validateTransfersAddresses has an error.

IllegalStateException - If the transfers are not all valid

IllegalStateException - If there is not enough balance in the inputs to supply to the transfers

See Also:

prepareTransfers(String, int, List, String, List, List, boolean), sendTrytes(String[], int, int, String), validateTransfersAddresses(String, int, List)

traverseBundle

public Bundle traverseBundle(String trunkTx,
                             String bundleHash,
                             Bundle bundle)
                      throws ArgumentException

Traverses the Bundle by going down the trunkTransactions until the bundle hash of the transaction changes. In case the input transaction hash is not a tail, we return an error.

Parameters:

trunkTx - Hash of a trunk or a tail transaction of a bundle.

bundleHash - The bundle hash. Should be null, and will use the transactions bundle hash

bundle - Bundle to be populated by traversing.

Returns:

Transaction objects.

Throws:

ArgumentException - when trunkTx is invalid, or has no transactions

ArgumentException - when a transaction in the bundle has no reference to the bundle

ArgumentException - when the first transaction in the bundle is not a tail

initiateTransfer

public List<Transaction> initiateTransfer(int securitySum,
                                          String inputAddress,
                                          String remainderAddress,
                                          List<Transfer> transfers)
                                   throws ArgumentException

Prepares transfer by generating the bundle with the corresponding cosigner transactions. Does not contain signatures.

Parameters:

securitySum - The sum of security levels used by all co-signers.

inputAddress - Array of input addresses as well as the securitySum.

remainderAddress - Has to be generated by the cosigners before initiating the transfer, can be null if fully spent.

transfers - List of Transfer we want to make using the unputAddresses

Returns:

All the Transaction objects in this newly created transfer

Throws:

ArgumentException - when an address is invalid.

ArgumentException - when the security level is wrong.

IllegalStateException - when a transfer fails because their is not enough balance to perform the transfer.

IllegalStateException - When a remainderAddress is required, but not supplied

RuntimeException - When the total value from the transfers is not 0

initiateTransfer

public List<Transaction> initiateTransfer(int securitySum,
                                          String inputAddress,
                                          String remainderAddress,
                                          List<Transfer> transfers,
                                          List<Transaction> tips)
                                   throws ArgumentException

Prepares transfer by generating the bundle with the corresponding cosigner transactions. Does not contain signatures.

Parameters:

securitySum - The sum of security levels used by all co-signers.

inputAddress - Array of input addresses as well as the securitySum.

remainderAddress - Has to be generated by the cosigners before initiating the transfer, can be null if fully spent.

transfers - List of Transfer we want to make using the unputAddresses

tips - The starting points for checking if the balances of the input addresses contain enough to make this transfer This can be null

Returns:

All the Transaction objects in this newly created transfer

Throws:

ArgumentException - when an address is invalid.

ArgumentException - when the security level is wrong.

IllegalStateException - when a transfer fails because their is not enough balance to perform the transfer.

IllegalStateException - When a remainderAddress is required, but not supplied

RuntimeException - When the total value from the transfers is not 0

initiateTransfer

public List<Transaction> initiateTransfer(int securitySum,
                                          String inputAddress,
                                          String remainderAddress,
                                          List<Transfer> transfers,
                                          boolean testMode)
                                   throws ArgumentException

Prepares transfer by generating the bundle with the corresponding cosigner transactions. Does not contain signatures.

Parameters:

securitySum - The sum of security levels used by all co-signers.

inputAddress - Array of input addresses as well as the securitySum.

remainderAddress - Has to be generated by the cosigners before initiating the transfer, can be null if fully spent.

transfers - List of Transfer we want to make using the unputAddresses

testMode - If were running unit tests, set to true to bypass total value check

Returns:

All the Transaction objects in this newly created transfer

Throws:

ArgumentException - when an address is invalid.

ArgumentException - when the security level is wrong.

IllegalStateException - when a transfer fails because their is not enough balance to perform the transfer.

IllegalStateException - When a remainderAddress is required, but not supplied

RuntimeException - When the total value from the transfers is not 0

initiateTransfer

public List<Transaction> initiateTransfer(int securitySum,
                                          String inputAddress,
                                          String remainderAddress,
                                          List<Transfer> transfers,
                                          List<Transaction> tips,
                                          boolean testMode)
                                   throws ArgumentException

Prepares transfer by generating the bundle with the corresponding cosigner transactions. Does not contain signatures.

Parameters:

securitySum - The sum of security levels used by all co-signers.

inputAddress - Input address with checksum

remainderAddress - Has to be generated by the cosigners before initiating the transfer, can be null if fully spent.

transfers - List of Transfer we want to make using the inputAddress

tips - The starting points for checking if the balance of the input address contains enough to make this transfer. This can be null

testMode - If were running unit tests, set to true to bypass total value check

Returns:

All the Transaction objects in this newly created transfer

Throws:

ArgumentException - when an address is invalid.

ArgumentException - when the security level is wrong.

IllegalStateException - when a transfer fails because their is not enough balance to perform the transfer.

IllegalStateException - When a remainderAddress is required, but not supplied

RuntimeException - When the total value from the transfers is not 0

validateTransfersAddresses

public void validateTransfersAddresses(String seed,
                                       int security,
                                       List<String> trytes)
                                throws ArgumentException

Validates the supplied transactions with seed and security. This will check for correct input/output and key reuse

In order to do this we will generate all addresses for this seed which are currently in use. Address checksums will be regenerated and these addresses will be looked up, making this an expensive method call.

If no error is thrown, the transaction trytes are using correct addresses. This will not validate transaction fields.

Parameters:

seed - The tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

trytes - List of transaction trytes.

Throws:

ArgumentException - when we are sending to our own input addresses

ArgumentException - when we try to remove funds from an address that is not an input

ArgumentException - when we are sending from an address we have already used for sending

addRemainder

public List<String> addRemainder(String seed,
                                 int security,
                                 List<Input> inputs,
                                 Bundle bundle,
                                 String tag,
                                 long totalValue,
                                 String remainderAddress,
                                 List<String> signatureFragments)
                          throws ArgumentException

Uses input, and adds to the bundle, untill totalValue is reached. If there is a remainder left on the last input, a remainder transfer is added.

Parameters:

seed - The tryte-encoded seed. It should be noted that this seed is not transferred.

security - Security level to be used for the private key / address. Can be 1, 2 or 3.

inputs - List of inputs used for funding the transfer.

bundle - The Bundle to be populated.

tag - The tag to add to each bundle entry (input and remainder)

totalValue - The total value of the desired transaction

remainderAddress - The address used for sending the remainder value (of the last input). If this is null, generateNewAddresses(AddressRequest) is used.

signatureFragments - The signature fragments (message), used for signing. Should be 2187 characters long, can be padded with 9s.

Returns:

A list of signed inputs to be used in a transaction

Throws:

ArgumentException - When the seed is invalid

ArgumentException - When the security level is wrong.

IllegalStateException - When the inputs do not contain enough balance to reach totalValue.

See Also:

IotaAPIUtils.signInputsAndReturn(String, List, Bundle, List, org.iota.jota.pow.ICurl), generateNewAddresses(AddressRequest)

isPromotable

public boolean isPromotable(Transaction tail)
                     throws ArgumentException

Checks if a transaction hash is promotable

Parameters:

tail - the Transaction we want to promote

Returns:

true if it is, otherwise false

Throws:

ArgumentException - when we can't get the consistency of this transaction

See Also:

IotaAPICore.checkConsistency(String...)

isPromotable

public boolean isPromotable(String tail)
                     throws ArgumentException

Checks if a transaction hash is promotable

Parameters:

tail - the Transaction hash we want to check

Returns:

true if it is, otherwise false

Throws:

ArgumentException - when we can't get the consistency of this transaction or when the transaction is not found

See Also:

IotaAPICore.checkConsistency(String...)

promoteTransaction

public List<Transaction> promoteTransaction(String tail,
                                            int depth,
                                            int minWeightMagnitude,
                                            Bundle bundle)
                                     throws BaseException

Attempts to promote a transaction using a provided bundle and, if successful, returns the promoting Transactions. This is done by creating another transaction which points to the tail. This will effectively double the chances of the transaction to be picked, and this approved.

Parameters:

tail - bundle tail to promote, cannot be null

depth - depth for getTransactionsToApprove

minWeightMagnitude - minWeightMagnitude to use for Proof-of-Work

bundle - the Bundle to attach for promotion

Returns:

List of the bundle Transactions made with the attached transaction trytes

Throws:

ArgumentException - When the bundle has no transaction

ArgumentException - When depth or minWeightMagnitude is lower than 0

ArgumentException - When the tail hash is invalid

NotPromotableException - When the transaction is not promotable

BaseException

See Also:

IotaAPICore.checkConsistency(String...), IotaAPICore.getTransactionsToApprove(Integer, String), IotaAPICore.attachToTangle(String, String, Integer, String...), storeAndBroadcast(String...)