参数编码与解码

pragma solidity 0.8.6;

contract Example {
    function baz(uint32 x, bool y) public pure returns (bool r) { 
        r = x > 32 || y; 
    }
}

pragma solidity 0.8.6;

contract Example {
    function bar(bytes3[2] memory) public pure {}
}

function transfer(address to, uint256 value) public returns (bool);

BASE_URL=https://api.shasta.trongrid.io   # 示例端点——可替换为实际可用的 TRON 节点
curl -X POST ${BASE_URL}/wallet/triggersmartcontract -d '{
  "contract_address":"412dd04f7b26176aa130823bcc67449d1f451eb98f",
  "owner_address":"411fafb1e96dfe4f609e2259bfaf8c77b60c535b93",
  "function_selector":"transfer(address,uint256)",
  "parameter":"0000000000000000000000002ed5dd8a98aea00ae32517742ea5289761b2710e0000000000000000000000000000000000000000000000000000000ba43b7400",
  "call_value":0,
  "fee_limit":1000000000,
  "call_token_value":0,
  "token_id":0
}'

// 建议使用 ethers 4.0.47 版本
var ethers = require('ethers')

const AbiCoder = ethers.utils.AbiCoder;
const ADDRESS_PREFIX_REGEX = /^(41)/;
const ADDRESS_PREFIX = "41";

async function encodeParams(inputs){
    let typesValues = inputs
    let parameters = ''

    if (typesValues.length == 0)
        return parameters
    const abiCoder = new AbiCoder();
    let types = [];
    const values = [];

    for (let i = 0; i < typesValues.length; i++) {
        let {type, value} = typesValues[i];
        if (type == 'address')
            value = value.replace(ADDRESS_PREFIX_REGEX, '0x');
        else if (type == 'address[]')
            value = value.map(v => toHex(v).replace(ADDRESS_PREFIX_REGEX, '0x'));
        types.push(type);
        values.push(value);
    }

    console.log(types, values)
    try {
        parameters = abiCoder.encode(types, values).replace(/^(0x)/, '');
    } catch (ex) {
        console.log(ex);
    }
    return parameters
}

async function main() {
    let inputs = [
        {type: 'address', value: "412ed5dd8a98aea00ae32517742ea5289761b2710e"},
        {type: 'uint256', value: 50000000000}
    ]
    let parameters = await encodeParams(inputs)
    console.log(parameters)
}

main()

export NILE_PRIVATE_KEY="<64-character-hex-private-key>"
export NILE_TRC20_CONTRACT_ADDRESS="<deployed-Nile-TRC20-contract-address>"

import java.math.BigInteger;
import java.util.Arrays;
import org.bouncycastle.util.encoders.Hex;
import org.tron.trident.abi.FunctionEncoder;
import org.tron.trident.abi.TypeReference;
import org.tron.trident.abi.datatypes.Address;
import org.tron.trident.abi.datatypes.Bool;
import org.tron.trident.abi.datatypes.Function;
import org.tron.trident.abi.datatypes.generated.Uint256;
import org.tron.trident.core.ApiWrapper;
import org.tron.trident.proto.Contract.TriggerSmartContract;
import org.tron.trident.proto.Response.TransactionExtention;

public class EncodeTrc20Parameters {
    public static void main(String[] args) {
        String privateKey = requirePrivateKey("NILE_PRIVATE_KEY");
        String contractAddress = requireTronAddress("NILE_TRC20_CONTRACT_ADDRESS");
        ApiWrapper client = ApiWrapper.ofNile(privateKey);

        try {
            // transfer(address,uint256) returns (bool)
            Function trc20Transfer = new Function(
                    "transfer",
                    Arrays.asList(
                            new Address("TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA"),
                            new Uint256(BigInteger.TEN.multiply(BigInteger.TEN.pow(6)))),
                    Arrays.asList(new TypeReference<Bool>() {}));

            String encodedHex = FunctionEncoder.encode(trc20Transfer);
            String ownerAddress = client.keyPair.toBase58CheckAddress();

            TriggerSmartContract trigger = TriggerSmartContract.newBuilder()
                    .setOwnerAddress(ApiWrapper.parseAddress(ownerAddress))
                    .setContractAddress(ApiWrapper.parseAddress(contractAddress))
                    .setData(ApiWrapper.parseHex(encodedHex))
                    .build();

            TransactionExtention txnExt = client.blockingStub.triggerContract(trigger);
            if (!txnExt.getResult().getResult()) {
                throw new IllegalStateException(
                        "triggerContract failed: "
                                + txnExt.getResult().getMessage().toStringUtf8());
            }

            System.out.println("encoded data => " + encodedHex);
            System.out.println("txn id => " + Hex.toHexString(txnExt.getTxid().toByteArray()));
        } finally {
            client.close();
        }
    }

    private static String requirePrivateKey(String name) {
        String value = requireEnv(name);
        if (!value.matches("(?i)^[0-9a-f]{64}$")) {
            throw new IllegalArgumentException(name + " must be a 64-character hex private key");
        }
        return value;
    }

    private static String requireTronAddress(String name) {
        String value = requireEnv(name);
        try {
            if (!value.startsWith("T") || ApiWrapper.parseAddress(value).size() != 21) {
                throw new IllegalArgumentException();
            }
        } catch (RuntimeException e) {
            throw new IllegalArgumentException(name + " must be a valid Base58Check TRON address", e);
        }
        return value;
    }

    private static String requireEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalStateException("Missing required environment variable: " + name);
        }
        return value.trim();
    }
}

BASE_URL=https://api.trongrid.io   # 示例端点——可替换为实际可用的 TRON 节点
curl -X POST \
  ${BASE_URL}/wallet/gettransactionbyid \
  -d '{"value" : "1472178f0845f0bfb15957059f3fe9c791e7e039f449c3d5a843aafbc8bbdeeb"}'

{
    "ret": [
        {
            "contractRet": "SUCCESS"
        }
    ],
    "raw_data": {
        "contract": [
            {
                "parameter": {
                    "value": {
                        "data": "a9059cbb0000000000000000000000002ed5dd8a98aea00ae32517742ea5289761b2710e0000000000000000000000000000000000000000000000000000000ba43b7400",
                        "owner_address": "418a4a39b0e62a091608e9631ffd19427d2d338dbd",
                        "contract_address": "41a614f803b6fd780986a42c78ec9c7f77e6ded13c"
                    },
                    "type_url": "type.googleapis.com/protocol.TriggerSmartContract"
                }
            }
        ]
    }
}

var ethers = require('ethers')

const AbiCoder = ethers.utils.AbiCoder;
const ADDRESS_PREFIX_REGEX = /^(41)/;
const ADDRESS_PREFIX = "41";

// types: 返回的参数类型数组。如果是多参数，需与函数 ABI 声明顺序严格一致
// output: 待解码的十六进制数据流
// ignoreMethodHash: 如果是解码函数返回值（如 balanceOf），传 false；如果是解码 gettransactionbyid 得到的 data 字段（含 Selector），传 true
async function decodeParams(types, output, ignoreMethodHash) {
    if (!output || typeof output === 'boolean') {
        ignoreMethodHash = output;
        output = types;
    }

    if (ignoreMethodHash && output.replace(/^0x/, '').length % 64 === 8)
        output = '0x' + output.replace(/^0x/, '').substring(8);

    const abiCoder = new AbiCoder();

    if (output.replace(/^0x/, '').length % 64)
        throw new Error('The encoded string is not valid. Its length must be a multiple of 64.');
    return abiCoder.decode(types, output).reduce((obj, arg, index) => {
        if (types[index] == 'address')
            arg = ADDRESS_PREFIX + arg.substr(2).toLowerCase();
        obj.push(arg);
        return obj;
    }, []);
}

async function main() {
    let data = '0xa9059cbb0000000000000000000000004f53238d40e1a3cb8752a2be81f053e266d9ecab000000000000000000000000000000000000000000000000000000024dba7580'

    result = await decodeParams(['address', 'uint256'], data, true)
    console.log(result)
}

main()

function balanceOf(address who) public view returns (uint256);

BASE_URL=https://api.shasta.trongrid.io   # 示例端点——可替换为实际可用的 TRON 节点
curl -X POST ${BASE_URL}/wallet/triggerconstantcontract -d '{
  "contract_address":"419E62BE7F4F103C36507CB2A753418791B1CDC182",
  "function_selector":"balanceOf(address)",
  "parameter":"0000000000000000000000000583A68A3BCD86C25AB1BEE482BAC04A216B0261",
  "owner_address":"41977C20977F412C2A1AA4EF3D49FEE5EC4C31CDFB"
}'

{
    "result": {
        "result": true
    },
    "constant_result": [
        "000000000000000000000000000000000000000000000000000196ca228159aa"
    ]
}

async function main() {
    // 解码时必须以 '0x' 作为十六进制前缀
    let outputs = '0x000000000000000000000000000000000000000000000000000196ca228159aa'
    
    // 传入的类型数组应与返回值对应。如果是多个返回值，按顺序填入
    let result = await decodeParams(['uint256'], outputs, false)
    console.log(result)
}

final String DATA = "a9059cbb0000000000000000000000007fdf5157514bf89ffcb7ff36f34772afd4cdc7440000000000000000000000000000000000000000000000000de0b6b3a7640000";

public void dataDecodingTutorial() {
    String rawSignature = DATA.substring(0,8);
    String signature = "transfer(address,uint256)"; // 预期的函数签名
    Address rawRecipient = TypeDecoder.decodeAddress(DATA.substring(8,72)); // 解码得到 Address 实例
    String recipient = rawRecipient.toString();
    Uint256 rawAmount = TypeDecoder.decodeNumeric(DATA.substring(72,136), Uint256.class); // 解码得到数字
    BigInteger amount = rawAmount.getValue();

    System.out.println(signature);
    System.out.println("Transfer " + amount + " to " + recipient);
}

public BigInteger balanceOf(String accountAddr) {
    // 构造查询函数
    Function balanceOf = new Function(
        "balanceOf",
        Arrays.asList(new Address(accountAddr)), 
        Arrays.asList(new TypeReference<Uint256>() {})
    );
    // 发起本地常数模拟调用
    TransactionExtention txnExt = wrapper.constantCall(
        Base58Check.bytesToBase58(ownerAddr.toByteArray()), 
        Base58Check.bytesToBase58(cntrAddr.toByteArray()), 
        balanceOf
    );
    // 将 ByteString 结果解析为十六进制字符串
    String result = Numeric.toHexString(txnExt.getConstantResult(0).toByteArray());
    return (BigInteger) FunctionReturnDecoder.decode(result, balanceOf.getOutputParameters()).get(0).getValue();
}