• release icerockdev/moko-network#149 feature of moko-network (websockets support for ktor-client)
• sample app will depend on moko-network to use websockets on iOS. but moko-web3 library will not depends on moko-network.
• implement subscription logic https://web3js.readthedocs.io/en/v1.2.7/web3-eth-subscribe.html
• test usage on https://infura.io/docs/ethereum/wss/eth-subscribe

But Bsc returns it without effective gas price, so it should be nullable

Problem: Now the class has dependence on web3. SmartContract can do requests to write/read self to/from blockchain. As I see it is violation of SRP
Solution: To communicate via web3 protocol we have Web3 entity, so we can add extensions for it (or just member functions) like web3.writeContract/web3.readContract. If it is important to have such functions in SmartContract, we can also add write and read methods, but we should pass web3 there explicitly, so it won't be violation of SRP in my opinion since we just delegate the work to web3.

our dependencies support all platforms and we not use expect/actual - it's time to publish for all platforms

now we can do one RPC by one http request. but JRPC support batch calls, so we should add this

append here references to the StringBuilder but not the the String

abstract class Web3Deserializer : DeserializationStrategy {
    override fun descriptor = /* STRING */
    override fun decode(decoder) {
        val string = decoder.decodeString()
        return decode(string.chunked(size = PART_SIZE * 2).map { it.hexStringToByteArray() })
    }
    abstract fun decode(chunks: List<ByteArray>)
}

And other help classes for SerializationStrategy and KSerializer (composition of this twos), so I won't write boilerplate with chunked and converting to hex

So I already implemented this on my fork by creating a separate branch: ionspinbignum

It is using ionspin's bignum library which supports arm64 targets already instead of soywiz's kbignum as the big number library. kbignum would need to put a new release out to support arm64.

In addition, to me, it seems like ionspin's library is more actively maintained and has more features. Would switching to using ionspin's big number library be a possibility to support arm64 targets?

• feature list
• usages
• description
• logo

We should introduce convenient types for HEX strings:

• hex string interface with 3 members HexString#withoutPrefix, HexString#prefixed, HexString#bigInt.
• value class for any valid hex string. checks if the string matches format.
• value class HexN(size: Int) for sized hexes (N - bytes count), delegates hex string interface with value class and additionally check the size
• shortcuts such as Hex32, Hex16, etc. for use in library.

And make ContractAddress (and similar classes) also delegate hex string interface with Hex20 class.

See the implementation here:
https://github.com/ethers-io/ethers.js/blob/4166b2753d0d6b230a3a22b5a2b6c4e1906a7af7/packages/providers/src.ts/base-provider.ts#L1444-L1480

There are already serializers for all entities except TransactionHash. Since this is an inline class, I can just mark it with Serializable and it will be automatically serialized as primitive

This issue closes: #34

I know it was mentioned that transaction signing would be supported soon in #5. But, I see there's no issue created for it, so I'm just making one here. I'm just wondering is the eta is still for this month? Also, if any help is needed I'd be to contribute, lmk!

now we check at runtime that smart contract call is valid for ABI. but will be better if we will generate all necessary functions from ABI - it will give to us strong types and less errors like "invalid type" or "not all arguments passed".

for generation we can use https://github.com/square/kotlinpoet
for storage of ABI files we can use https://github.com/icerockdev/moko-resources

sample app:

• show balance of wallet (input field at screen)
• show transactions of wallet

I'm trying to simply get the name of a ERC721 contract.

    val apiKey = "..."
    val web3: Web3 = Web3("https://mainnet.infura.io/v3/$apiKey")
    val smartContractString = "..."
    val smartContractJson = Json.parseToJsonElement(smartContractString).jsonObject
    val networkData : JsonObject = smartContractJson["networks"]!!.jsonObject[networkId]?.jsonObject!!
    val adr  = networkData["address"]?.jsonPrimitive?.content!!
    val abis = smartContractJson["abi"]!!.jsonArray

    val sc = SmartContract(web3, ContractAddress(adr), abis))
    
    val names = sc.read("name", emptyList())
            { l ->
                l.map {
                    it.toString()
                }
            }
    val contractName = names[0]
        

First of all I'm not really sure what a valid mapper would look like? Or why it would return multiple values from one read. Do you have any examples? And second, names ends up being empty, so nothing is being returned? Any help on the correct way to call a contract method would be appreciated.

There should be a function to check checksumed address for validity

https://coincodex.com/article/2078/ethereum-address-checksum-explained/

• automatically remove "0x" prefix if there is the one
• throw an exception if the input is invalid (length is even or contains not hex symbols)
• replace forEach iterator step 2 with chunked and map

This is a meta issue

https://docs.soliditylang.org/en/v0.5.3/abi-spec.html#argument-encoding

Children:

• Static Types
  • uint256
  • address
  • uint8
  • #96
  • todo // add all not implemented types here
• Dynamic Types
  • #21
  • #74
  • #85
  • #86
  • Array serializer with fixed amount of elements T[k]

Right now there is a need in extended eth_estimateGas method to properly get gasLimit for transaction.

Web3RpcRequest(
    method = "eth_sendRawTransaction",
    params = listOf(signedTransaction),
    paramsSerializer = String.serializer(),
    resultSerializer = String.serializer(),
    transform = ::TransactionHash
)

@Alex009, what do you think about such a thing?

It's useful for cases when we want to wrap request result in typed stuff like on screenshot below:

Now that works fine and I can add a request to the separate entity, but when I try to use it with a batch request, it becomes kinda verbose because I have a String output, but not a TokenCryptoCurrency? one.

This is important for such cases:

Since Infura is just a realization of web3 protocol, all names related to infura should be changed to names related to web3 (e.g. infuraUrl => web3Url).
Pros:
It is open source project and we won't push users to use infura.
Cons:
Migration, but it shouldn't cause a lot of problems since there is only one tech-preview project use this library.

It is useful for cases when I need an ability to execute some requests, but don't need all functionality of Web3 class

• eth_gasPrice

Now "latest" block state is hard coded, but there should be type-safe way to specify it

Some networks (bsc testnet for example) don't work without this header.

Now we can't parse such results