EthereumSigningOutput get wrong hexString

[IhorStasiv]

Describe the bug
I am trying to send a BEP20 token,
I send 1BitShiba, but EthereumSigningOutput.encoded.hexString returns me the time in which 16BitShiba is sent.

To Reproduce
myCode: Swift language

          APIManager.shared.doPostTransaction2(chain: tokenModel.chain, id: 1, jsonRPC: "2.0", method: "eth_gasPrice") { [weak self] model, error in //BaseURL - https://bsc-dataseed.binance.org
                      guard let strongSelf = self, let ethGasPrice = model?.result else {
                          self?.showResultState()
                          return
                      }
                      let chainID = "0x" + String(format:"%02X", strongSelf.tokenModel.chain.getNumberId())
                      APIManager.shared.doPostTransaction2( //BaseURL - https://bsc-dataseed.binance.org
                          chain: strongSelf.tokenModel.chain,
                          id: 1,
                          jsonRPC: "2.0",
                          method: "eth_getTransactionCount",
                          params: [wallet.getAddressForCoin(coin: .ethereum), "latest"]) { [weak self] model, error in
                              guard let ethTransactionCount = model?.result else {
                                  strongSelf.showResultState()
                                  return
                              }
                              var signingInput = EthereumSigningInput.with {
                                  $0.toAddress = strongSelf.tokenModel.address
                                  $0.chainID = Data(hexString: chainID)!
                                  $0.nonce = Data(ethTransactionCount)!
                                  $0.gasPrice = Data(ethGasPrice)!
                                  $0.gasLimit = Data(hexString: "0xDBA4")!
                                  $0.transaction = EthereumTransaction.with({
                                      $0.erc20Transfer = EthereumTransaction.ERC20Transfer.with({
                                          $0.to = strongSelf.cryptoSendModel.toAddress
                                          $0.amount = Data(strongSelf.representationOf(Decimal(strongSelf.amountToSend.replacingOccurrences(of: ",", with: ""), base: 10), base: 16))!
                                      })
                                  })
                                  $0.privateKey = wallet.getKeyForCoin(coin: .ethereum).data
                              }
                              let output: EthereumSigningOutput = AnySigner.sign(input: signingInput, coin: .ethereum)
                              APIManager.shared.doPostTransaction2( //BaseURL - https://bsc-dataseed.binance.org
                                  chain: strongSelf.tokenModel.chain,
                                  id: 1,
                                  jsonRPC: "2.0",
                                  method: "eth_sendRawTransaction",
                                  params: ["0x" + output.encoded.map({ String(format: "%02x", $0) }).joined()]) { [weak self] model, error in //TODO invalid argument 0: json: cannot unmarshal hex string without 0x prefix into Go value of type hexutil.Bytes
                                      guard let hash = model?.result else {
                                          strongSelf.showResultState()
                                          return
                                      }
                                      strongSelf.showResultState(hash: hash)
                                  }
                          }
                  }

Expected behavior
I expect that the code will send as many tokens as I specified and not x16 of the specified number

Additional context
Your methods for converting a hexString to a Data return nil
although they can actually convert a string to a data, namely nil is returned in places

      public init?(hexString: String) {
          let string: String
          if hexString.hasPrefix("0x") {
              string = String(hexString.dropFirst(2))
          } else {
              string = hexString
          }
  
          // Check odd length hex string
          if string.count % 2 != 0 {
              return nil <--------  When i try to path "ethGasPrice"
          }
  
          // Check odd characters
          if string.contains(where: { !$0.isHexDigit }) {
              return nil <--------  When i try to path "ethTransactionCount"
          }
  
          // Convert the string to bytes for better performance
          guard let stringData = string.data(using: .ascii, allowLossyConversion: true) else {
              return nil
          }
  
          self.init(capacity: string.count / 2)
          let stringBytes = Array(stringData)
          for i in stride(from: 0, to: stringBytes.count, by: 2) {
              guard let high = Data.value(of: stringBytes[i]) else {
                  return nil
              }
              if i < stringBytes.count - 1, let low = Data.value(of: stringBytes[i + 1]) {
                  append((high << 4) | low)
              } else {
                  append(high)
              }
          }
      }

therefore, I tried to comment out these terms to get data from my terms.
So that is txhash: 0x9d4af6d8c62197268a4fea5bf62253ef325ec5777cbd1d95405cd1e20242fd1d

HexString after EthereumSigningOutput.encoded.hexString looks something like that:

            f8aa7e8512a05f200082dba494b84cbbf09b3ed388a45cd875ebba41a20365e6e780b844a9059cbb000000000000000000000000c3f069f88af54d17dd025538d532dd72ca9a1666000000000000000000000000000000000000000000000000de0b6b3a764000008194a0181d6eb601a57686bce9b97ebbda0cefa493c2380f40f49121fb0f71410872d4a06b625ed3e30d459f62c3dc147763e0e2a06cb46a5bd036f8a74c2c924c6272e9

i can see amount here: 000000000000000000000000000000000000000000000000de0b6b3a76400000
but that is not but this is not amount what I am conveying,
my amount is de0b6b3a7640000(1000000000000000000)
Im trying to drop zero from end, and put it to start than i get an error says "insufficient funds for gas * price + value"
What is price and value which is error mentioned?
And how can i get correct amount?

[optout21]

Apparently your amount conversion logic is wrong.
Hex e0b6b3a76400000 is decimal 16000000000000000000, which -- assuming 18 decimal precision -- is 16.0 units.
You have not provided what was the input amount.
The first step -- replacing of the comma works, but only if the representation has exactly 18 decimals, otherwise it is very dangerous. You should multiply the amount by Bignum 10^18, instead of string operations.
Fix and test your amount conversion separately first.
There is nothing wrong with the hexString to Data method.

                 $0.amount = Data(strongSelf.representationOf(Decimal(strongSelf.amountToSend.replacingOccurrences(of: ",", with: ""), base: 10), base: 16))!
                        

Closing.

[VladyslavKozlovskyi]

Hi @catenocrypt
I faced a similar issue
I want to send 1.0 Shiba, and my decimal to hex converter returns de0b6b3a7640000

but in the transition parameters, I see de0b6b3a76400000 (on one more 0 than I need) and its equally 16.0

[VladyslavKozlovskyi]

[VladyslavKozlovskyi]

also exciting fact, I can enter different amounts and in 90% I will see an additional 0 at the end of my correct amount

[optout21]

I recommend to use BigInt package, and:

import BigInt

$0.amount = BigInt(1*1000000000000000000).magnitude.serialize()

[VladyslavKozlovskyi]

I already using Decimal
also, my first step was to integrate this logic for Android (Kotlin) and later copy-paste it to iOS, Android works as expected

[VladyslavKozlovskyi]

I think something happens when EthereumSigningOutput is converting to hex single parameter string

[optout21]

This Decimal does not look like the built-in Decimal, so I cannot test or comment on it.

[optout21]

EthereumSigningIntput takes a byte array, so no more hex/string/decimal conversion takes place there. The Data constructor with a hex string is another question, I would not use hex string representation in this case. I'm not sure where exactly the incorrect odd-length hex string is created or being mishandled.

[VladyslavKozlovskyi]

Hi @catenocrypt
Thank you, that's resolved my issue 🚀🚀🚀

[optout21]

Note: I have updated our reference iOS sample app to use BigInt, instead of hardcoded hex values it uses now cleanly converted amount:

https://github.com/trustwallet/wallet-core/blob/master/samples/osx/cocoapods/WalletCoreExample/ViewController.swift#L37

[sholaakinrolie]

Hi Friends</>

Trust you are good!
I’m Shola, Developer Advocacy at Trust Wallet!

If you have ever contributed to Wallet Core or any of our open-source projects, you deserve some accolades and I am happy to chat about this!

Pls, drop your contact, and I will reach out or shoot me an email: [email protected] or connect with me on:
Twitter @meetslick
Linkedin: Shola Slick Akinrolie
Telegram: @sholaakinrolie

Let’s talk!