Core Features

Blockchains supported

Usage

Initialization

val context=Application()val address=Address("0x..your..address")val evmKit=EthereumKit.getInstance(    context,    address,Chain.Ethereum,RpcSource.ethereumInfuraHttp("projectId","projectSecret"),TransactionSource.ethereumEtherscan("apiKey"),"unique_wallet_id")

Starting and Stopping

evmKit.start()evmKit.stop()

Get wallet data

evmKit.accountState?.let { state->    state.balance    state.nonce}evmKit.lastBlockHeight

evmKit.accountStateFlowable.subscribe { state->println("balance:${state.balance}); nonce:${state.nonce}") }evmKit.lastBlockHeightFlowable.subscribe { height->println(height) }evmKit.syncStateFlowable.subscribe { state->println(state) }evmKit.transactionsSyncStateFlowable.subscribe { state->println(state) }// Subscribe to ETH transactions synced by the kitevmKit.getFullTransactionsFlowable(listOf(listOf("ETH"))).subscribe { transactions->println(transactions.size) }// Subscribe to all EVM transactionsevmKit.allTransactionsFlowable.subscribe { transactionsPair->println(transactionsPair.first.size) }

Send Transaction

val seed=Mnemonic().toSeed(listOf("mnemonic","phrase"),"passphrase_if_exists'")val signer=Signer.getInstance(seed,Chain.Ethereum)

val toAddress=Address("0x..recipient..address..here")val amount=BigInteger("100000000000000000")// 0.1 ETH in WEIsval gasPrice=GasPrice.Legacy(50_000_000_000)// Construct TransactionData which is the key payload of any EVM transactionval transactionData= ethereumKit.transferTransactionData(toAddress, amount)// Estimate gas for the transactionval estimateGasSingle= ethereumKit.estimateGas(transactionData, gasPrice)// Generate a raw transaction which is ready to be signed. This step also synchronizes the nonceval rawTransactionSingle= estimateGasSingle.flatMap { estimateGasSingle->    ethereumKit.rawTransaction(transactionData, gasPrice, estimateGasSingle)}val sendSingle= rawTransactionSingle.flatMap { rawTransaction->// Sign the transactionval signature= signer.signature(rawTransaction)// Send the transaction to RPC node    ethereumKit.send(rawTransaction, signature)}// This step is needed for Rx reactive code to runval disposables=CompositeDisposable()sendSingle.subscribe { fullTransaction->// ethereumKit.send returns FullTransaction object that contains transaction and a transaction decorationval transaction= fullTransaction.transactionprintln("Transaction sent:${transaction.hash.toHexString()}")println("To:${transaction.to?.let { it.eip55 }}")println("Amount:${transaction.value?.let { it.toString(10) }}")}.let {    disposables.add(it)}

Get ETH transactions

ethereumKit.getFullTransactionsAsync(listOf(listOf("ETH")))        .subscribe { fullTransactions->for (fullTransactionin fullTransactions) {println("Transaction hash:${fullTransaction.transaction.hash.toHexString()}")when (val decoration= fullTransaction.decoration) {isIncomingDecoration-> {println("From:${decoration.from.eip55}")println("Amount:${decoration.value.toString(10)}")                    }isOutgoingDecoration-> {println("To:${decoration.to.eip55}")println("Amount:${decoration.value.toString(10)}")                    }else-> {}                }            }        }.let {            disposables.add(it)        }

EIP20 tokens

Initialization

val contractAddress=Address("0x..token..contract..address..")val erc20Kit=Erc20Kit.getInstance(context, ethereumKit, contractAddress)// Decorators are needed to detect transactions as `Erc20` transfer/approve transactionsErc20Kit.addTransactionSyncer(ethereumKit)// Erc20 transactions syncer is needed to pull Eip20 transfer transactions from EtherscanErc20Kit.addDecorators(ethereumKit)

Get token balance

erc20Kit.balance?.let { balance->println(balance.toString(10))}

Send Erc20 transfer transaction

val toAddress=Address("0x..recipient..address..here")val amount=BigInteger("100000000000000000")val gasPrice=GasPrice.Legacy(50_000_000_000)// Construct TransactionData which calls a `Transfer` method of the EIP20 compatible smart contractval transactionData= erc20Kit.buildTransferTransactionData(toAddress, amount)ethereumKit.estimateGas(transactionData, gasPrice)        .flatMap { estimateGasSingle->            ethereumKit.rawTransaction(transactionData, gasPrice, estimateGasSingle)        }        .flatMap { rawTransaction->val signature= signer.signature(rawTransaction)            ethereumKit.send(rawTransaction, signature)        }        .subscribe { fullTransaction->println("Transaction sent:${fullTransaction.transaction.hash.toHexString()}")val decoration= fullTransaction.decorationas?OutgoingDecoration?:return@subscribeprintln("To:${decoration.to.eip55}")println("Amount:${decoration.value.toString(10)}")        }.let {            disposables.add(it)        }

Get Erc20 transactions

ethereumKit.getFullTransactionsAsync(listOf(listOf(contractAddress.eip55)))        .subscribe { fullTransactions->for (fullTransactionin fullTransactions) {println("Transaction sent:${fullTransaction.transaction.hash.toHexString()}")when (val decoration= fullTransaction.decoration) {isIncomingDecoration-> {println("From:${decoration.from.eip55}")println("Amount:${decoration.value.toString(10)}")                    }isOutgoingDecoration-> {println("To:${decoration.to.eip55}")println("Amount:${decoration.value.toString(10)}")                    }else-> {}                }            }        }.let {            disposables.add(it)        }

Uniswap

Initialization

val uniswapKit=UniswapKit.getInstance(ethereumKit)// Decorators are needed to detect and decorate transactions as `Uniswap` transactionsUniswapKit.addDecorators(ethereumKit)

Send sample swap transaction

// Sample swap dataval tokenIn= uniswapKit.etherToken()val tokenOut= uniswapKit.token(Address("0x..token..address"),18)val amount=BigDecimal(1)val gasPrice=GasPrice.Legacy(50_000_000_000)// Get SwapData. SwapData is a list of pairs available in Uniswap smart contract at the momentuniswapKit.swapData(tokenIn, tokenOut)        .map { swapData->// Get TradeData. TradeData is the best swap route evaluated by UniswapKitval tradeData= uniswapKit.bestTradeExactIn(swapData, amount)// Convert TradeData to EvmKit TransactionData            uniswapKit.transactionData(tradeData)        }        .flatMap { transactionData->            ethereumKit.estimateGas(transactionData, gasPrice)                    .flatMap { estimateGasSingle->                        ethereumKit.rawTransaction(transactionData, gasPrice, estimateGasSingle)                    }        }        .flatMap { rawTransaction->val signature= signer.signature(rawTransaction)            ethereumKit.send(rawTransaction, signature)        }        .subscribe { fullTransaction->println("Transaction sent:${fullTransaction.transaction.hash.toHexString()}")        }.let {            disposables.add(it)        }

ExactIn/ExactOut

Trade Options

1Inch

Initialization

val oneInchKit=OneInchKit.getInstance(ethereumKit)OneInchKit.addDecorators(ethereumKit)

Sample code to get swap data from 1Inch API, sign it and send to RPC node

// Sample swap dataval tokenFromAddress=Address("0x..from..token..address")val tokenToAddress=Address("0x..to..token..address")val amount=BigInteger("100000000000000000")val gasPrice=GasPrice.Legacy(50_000_000_000)// Get Swap object, evaluated transaction data by 1Inch aggregatoroneInchKit.getSwapAsync(        fromToken= tokenFromAddress,        toToken= tokenToAddress,        amount= amount,        slippagePercentage=1F,        recipient=null,        gasPrice= gasPrice)        .flatMap { swap->val tx= swap.transactionval transactionData=TransactionData(tx.to, tx.value, tx.data)            ethereumKit.rawTransaction(transactionData, gasPrice, tx.gasLimit)        }        .flatMap { rawTransaction->val signature= signer.signature(rawTransaction)            ethereumKit.send(rawTransaction, signature)        }        .subscribe { fullTransaction->println("Transaction sent:${fullTransaction.transaction.hash.toHexString()}")        }.let {            disposables.add(it)        }

NFTs

Initialization

val nftKit=NftKit.getInstance(App.instance, ethereumKit)nftKit.addEip721Decorators()nftKit.addEip1155Decorators()nftKit.addEip721TransactionSyncer()nftKit.addEip1155TransactionSyncer()

Get NFTs owned by the user

val nftBalances= nftKit.nftBalancesfor (nftBalancein nftBalances) {println("----${nftBalance.balance} pieces of${nftBalance.nft.tokenName} ---")println("Contract Address:${nftBalance.nft.contractAddress.eip55}")println("TokenID:${nftBalance.nft.tokenId.toString(10)}")}

Send an NFT

val nftContractAddress=Address("0x..contract..address")val tokenId=BigInteger("234123894712031638516723498")val to=Address("0x..recipient..address")val gasPrice=GasPrice.Legacy(50_000_000_000)// Construct a TransactionDataval transactionData= nftKit.transferEip721TransactionData(nftContractAddress, to, tokenId)ethereumKit.estimateGas(transactionData, gasPrice)        .flatMap { estimateGasSingle->            ethereumKit.rawTransaction(transactionData, gasPrice, estimateGasSingle)        }        .flatMap { rawTransaction->val signature= signer.signature(rawTransaction)            ethereumKit.send(rawTransaction, signature)        }        .subscribe { fullTransaction->println("Transaction sent:${fullTransaction.transaction.hash.toHexString()}")        }.let {            disposables.add(it)        }

Extending

Smart contract call

Prerequisites

Installation

repositories {    maven { url 'https://jitpack.io' }}

dependencies {    implementation 'com.github.horizontalsystems:ethereum-kit-android:master-SNAPSHOT'}

Example App

License