org.iota.jota

Class IotaAccount

java.lang.Object

org.iota.jota.IotaAccount

All Implemented Interfaces:

Account, EventListener, TaskService

public class IotaAccount
extends Object
implements Account, EventListener

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	IotaAccount.Builder

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	IotaAccount(AccountBuilder builder)
	IotaAccount(AccountOptions options)
	IotaAccount(String seed) Constructs a IotaAccount with a config based on environment variables or default values.
	IotaAccount(String seed, AccountStore store) Constructs a IotaAccount with a config based on environment variables or default values.
	IotaAccount(String seed, AccountStore store, AccountConfig iotaConfig) Constructs a IotaAccount with config
	IotaAccount(String seed, AccountStore store, String config) Constructs a IotaAccount with a config from String

Method Summary

Modifier and Type	Method and Description
long	availableBalance() Runs the input selection with the CDAs in order to determine the usable balance for funding transfers.
AccountState	exportAccount() Makes a copy of the current account state.
AccountStateManager	getAccountManager()
IotaAPI	getApi()
EventManager	getEventManager()
String	getId() Returns the account’s unique identifier which is a sha256 hash of the account’s seed.
SeedProvider	getSeed()
void	importAccount(AccountState state) Saves the current account state, then replaces it with the one provided.
boolean	isNew() Checks whether the state of the account is new.
void	load() Loads the account’s inner event loop to accept commands and provided plugins using current the account settings
void	load(String accountId, AccountState state)
Future<ConditionalDepositAddress>	newDepositAddress(Date timeOut, boolean multiUse, long expectedAmount, ExpireCondition... otherConditions) Future always completed Allocates a new CDA in the underlying store.
Future<ConditionalDepositAddress>	newDepositRequest(DepositRequest request, ExpireCondition... otherConditions)
Future<Bundle>	send(Recipient recipient) Future always completed Sends the specified amounts to the given recipient.
Future<Bundle>	send(String address, long amount, Optional<String> message, Optional<String> tag) Sends a transfer using the accounts balance to the provided address.
Future<Bundle>	send(String address, long amount, String message, String tag)
Future<Bundle>	sendMulti(String[] addresses, long amount, Optional<String> message, Optional<String> tag) NOT YET IMPLEMENTED
Future<Bundle>	sendZeroValue(Optional<String> message, Optional<String> tag, Optional<String> address) Future always completed
Future<Bundle>	sendZeroValue(String message, String tag, String address) Future always completed
void	shutdown() Shutdowns the account’s inner event loop and shutdowns all plugins.
boolean	start() Starts the account event loop
String	toString()
long	totalBalance() Uses all stored CDAs to determine the current total balance.
void	updateSettings(AccountOptions newSettings) Updates the settings of the account in a synchronized manner by shutting down all plugins, stopping the event loop, applying the settings and starting the newly defined plugins and kicking off the event loop again.

Methods inherited from class java.lang.Object

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

Constructor Detail

IotaAccount

public IotaAccount(AccountOptions options)

Parameters:

options -

IotaAccount

protected IotaAccount(AccountBuilder builder)

IotaAccount

public IotaAccount(String seed)
            throws Exception

Constructs a IotaAccount with a config based on environment variables or default values.

Parameters:

seed -

Throws:

Exception - If the config did not load for whatever reason

IotaAccount

public IotaAccount(String seed,
                   AccountStore store)
            throws Exception

Constructs a IotaAccount with a config based on environment variables or default values.

Parameters:

seed -

store - The method we use for storing key/value data

Throws:

Exception - If the config did not load for whatever reason

IotaAccount

public IotaAccount(String seed,
                   AccountStore store,
                   String config)
            throws Exception

Constructs a IotaAccount with a config from String

Parameters:

seed -

store - The method we use for storing key/value data

config - The location of the config

Throws:

Exception - If the config did not load for whatever reason

IotaAccount

public IotaAccount(String seed,
                   AccountStore store,
                   AccountConfig iotaConfig)
            throws Exception

Constructs a IotaAccount with config

Parameters:

seed -

store - The method we use for storing key/value data

iotaConfig - The config we load nodes from

Throws:

Exception - If the config did not load for whatever reason

Method Detail

load

public void load()

Description copied from interface: Account

Loads the account’s inner event loop to accept commands and provided plugins using current the account settings

Specified by:

load in interface Account

Specified by:

load in interface TaskService

load

public void load(String accountId,
                 AccountState state)
          throws AccountError

Throws:

AccountError

getId

public String getId()
             throws AccountError

Returns the account’s unique identifier which is a sha256 hash of the account’s seed.

Specified by:

getId in interface Account

Returns:

the account ID

Throws:

AccountError - When we failed to generate the ID

start

public boolean start()
              throws AccountError

Starts the account event loop

Specified by:

start in interface Account

Specified by:

start in interface TaskService

Returns:

true if loaded successful. otherwise false

Throws:

AccountError - When an error occurred during start-up

shutdown

public void shutdown()
              throws AccountError

Shutdowns the account’s inner event loop and shutdowns all plugins. Will gracefully shut down all plugins

Specified by:

shutdown in interface Account

Specified by:

shutdown in interface TaskService

Throws:

AccountError

availableBalance

public long availableBalance()
                      throws AccountError

Runs the input selection with the CDAs in order to determine the usable balance for funding transfers.

Specified by:

availableBalance in interface Account

Returns:

The amount of balance for this account which you can immediately use

Throws:

AccountError - When we failed to get the balance

totalBalance

public long totalBalance()
                  throws AccountError

Uses all stored CDAs to determine the current total balance.

Specified by:

totalBalance in interface Account

Returns:

The total balance of this account

Throws:

AccountError - When we failed to get the balance

isNew

public boolean isNew()

Checks whether the state of the account is new. An account is considered new if no pending transfers or CDAs are stored.

Specified by:

isNew in interface Account

Returns:

true if it is new, otherwise false

updateSettings

public void updateSettings(AccountOptions newSettings)
                    throws AccountError

Updates the settings of the account in a synchronized manner by shutting down all plugins, stopping the event loop, applying the settings and starting the newly defined plugins and kicking off the event loop again.

Specified by:

updateSettings in interface Account

Parameters:

newSettings - The new settings for this account

Throws:

AccountError - When we failed to update the settings

send

public Future<Bundle> send(String address,
                           long amount,
                           String message,
                           String tag)

send

public Future<Bundle> send(String address,
                           long amount,
                           Optional<String> message,
                           Optional<String> tag)

Sends a transfer using the accounts balance to the provided address. You must call .get() on the future in order to start this transfer.

Parameters:

address - The receiver of this transfer

amount - The amount we are sending to the address

message - An optional message for this transfer

tag - An optional tag for this transfer

Returns:

The bundle we sent

newDepositAddress

public Future<ConditionalDepositAddress> newDepositAddress(Date timeOut,
                                                           boolean multiUse,
                                                           long expectedAmount,
                                                           ExpireCondition... otherConditions)
                                                    throws AccountError

Future always completed Allocates a new CDA in the underlying store. Note: Specifying both multi-use and an expected amount is not allowed

Specified by:

newDepositAddress in interface Account

Parameters:

timeOut - The date this address expires

multiUse - If we expect multiple deposits

expectedAmount - The final balance we expect to have in this address before we expire

otherConditions - Currently unused, used to specify custom conditions

Returns:

ConditionalDepositAddress The newly generated CDA

Throws:

AccountError - When we were not able to generate a new address

newDepositRequest

public Future<ConditionalDepositAddress> newDepositRequest(DepositRequest request,
                                                           ExpireCondition... otherConditions)
                                                    throws AccountError

Throws:

AccountError

send

public Future<Bundle> send(Recipient recipient)
                    throws AccountError

Future always completed Sends the specified amounts to the given recipient.

Specified by:

send in interface Account

Parameters:

recipient - Information about the receiving end of the transactions

Returns:

The bundle we sent

Throws:

AccountError

sendZeroValue

public Future<Bundle> sendZeroValue(String message,
                                    String tag,
                                    String address)
                             throws ArgumentException,
                                    SendException

Future always completed

Parameters:

message - the optional message to use, can be null

tag - the optional tag to use, can be null

address - the optional address to use, can be null

Returns:

the sent bundle

Throws:

ArgumentException - If an argument is wrong

SendException - If an internal error happened whilst sending

sendZeroValue

public Future<Bundle> sendZeroValue(Optional<String> message,
                                    Optional<String> tag,
                                    Optional<String> address)
                             throws ArgumentException,
                                    SendException

Future always completed

Parameters:

message - the optional message to use

tag - the optional tag to use

Returns:

the sent bundle

Throws:

ArgumentException - If an argument is wrong

SendException - If an internal error happened whilst sending

sendMulti

public Future<Bundle> sendMulti(String[] addresses,
                                long amount,
                                Optional<String> message,
                                Optional<String> tag)

NOT YET IMPLEMENTED

Parameters:

addresses -

amount -

message -

tag -

Returns:

exportAccount

public AccountState exportAccount()

Makes a copy of the current account state. Modifications to the copy do not reflect in the original. The IotaAccount is still using the original account state

Returns:

a clone of the account state. or null if it failed

importAccount

public void importAccount(AccountState state)

Saves the current account state, then replaces it with the one provided. Provided state will also be saved to persist

Parameters:

state - the new account state

getSeed

public SeedProvider getSeed()

getApi

public IotaAPI getApi()

getEventManager

public EventManager getEventManager()

getAccountManager

public AccountStateManager getAccountManager()

toString

public String toString()

Overrides:

toString in class Object