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.

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.

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

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.

append here references to the StringBuilder but not the the String

https://github.com/icerockdev/moko-web3/blob/38b427785bce2a23211039ad51d31d553a7deab1/web3/src/commonMain/kotlin/dev.icerock.moko.web3/hex/internal/hexFormatUtil.kt#L7-L22

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?

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!

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.

This is a meta issue

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

Children:

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

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