Início / user-23039319

János Barna's questions

Martin Hope
János Barna
Asked: 2023-12-07 19:41:33 +0800 CST
  • 5

Estou tentando obter dados em meu contrato inteligente, que são obtidos de um adaptador externo Chainlink:

buscar ponte "{"dados":{"resultado":{"id":"UCAl9Ld79qaZxp9JzEOwd3aA","statistics":{"subscriberCount":"209000"}}},"jobRunId":"0x84aae6f7b7144fbc8196230158918797","statusCode": 200}"

Nome: Yutu

requestData: {"id": $(jobSpec.externalJobID), "data": { "chid": $(decode_cbor.chid)},"key": $(decode_cbor.key)}

analisar jsonparse "209000"

caminho: dados,resultado,estatísticas,subscriberCount

dados: $(buscar)

encode_data ethabiencode "0x00000000000000000000000000000000000000000000000000000033068"

abi: (valor uint256)

dados: { "valor": $(parse) }

encode_tx ethabiencode "0x4ab0d1902a02a37be17119894c2d9400f9bcf563bd4be47496af9a493a96eb412676916c000000000000000000000000000000000000000000 000000de0b6b3a764000000000000000000000000002e495ea15b191aff2dea171abba537dc597d6f117642d375000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000006571ad180000000000000000000000000000000000000000 00000000000000033068"

abi: cumprirOracleRequest (bytes32 requestId, pagamento uint256, endereço callbackAddress, bytes4 callbackFunctionId, expiração uint256, dados bytes32)

dados: {"requestId": $(decode_log.requestId), "pagamento": $(decode_log.payment), "callbackAddress": $(decode_log.callbackAddr), "callbackFunctionId": $(decode_log.callbackFunctionId), "expiração" : $(decode_log.cancelExpiration), "dados": $(encode_data)}

submit_tx ethtx para: 0x34b33d85A6a642A6Eaa1fE554f576c6122FF64b6

dados: $(encode_tx)

Estou tentando obter o número de assinantes no smartcontract abaixo: // SPDX-License-Identifier: MIT pragma solidity ^0.8.7;

importar "@chainlink/contracts/src/v0.8/ChainlinkClient.sol"; importar "@chainlink/contracts/src/v0.8/ConfirmedOwner.sol";

/**

  • ESTE É UM EXEMPLO DE CONTRATO QUE USA CÓDIGO NÃO AUDITADO.
  • NÃO USE ESTE CÓDIGO NA PRODUÇÃO. */

contrato ConsumerContract é ChainlinkClient, ConfirmedOwner {usando Chainlink para Chainlink.Request;

uint256 private constant ORACLE_PAYMENT = 1 * LINK_DIVISIBILITY; // 1 * 10**18
uint256 public lastRetrievedSubscriberCount;

event RequestForSubscriberCountFulfilled(
    bytes32 indexed requestId,
    uint256 indexed subscriberCount
);

/**
 *  Goerli
 * @dev LINK address in Sepholia network: 0x779877A7B0D9E8603169DdbD7836e478b4624789
 * @dev Check https://docs.chain.link/docs/link-token-contracts/ for LINK address for the right network
 */
constructor() ConfirmedOwner(msg.sender) {
    setChainlinkToken(0x779877A7B0D9E8603169DdbD7836e478b4624789);
}

function requestSubscriberCount(
    address _oracle,
    string memory _jobId,
    string memory channelId,
    string memory apiKey
) public onlyOwner {
    Chainlink.Request memory req = buildOperatorRequest(
        stringToBytes32(_jobId),
        this.fulfillRequestInfo.selector
    );

    req.add("chid", channelId);
    req.add("key", apiKey);
    sendOperatorRequestTo(_oracle, req, ORACLE_PAYMENT);
}

function fulfillRequestInfo(bytes32 _requestId, string memory _info)
    public
    recordChainlinkFulfillment(_requestId)
{
    // Parse the JSON data to extract the subscriberCount
    (uint256 subscriberCount, ) = abi.decode(bytes(_info), (uint256, uint256));

    emit RequestForSubscriberCountFulfilled(_requestId, subscriberCount);
    lastRetrievedSubscriberCount = subscriberCount;
}

function getSubscriberCount() public view returns (uint256) {
    return lastRetrievedSubscriberCount;
}

/*
========= UTILITY FUNCTIONS ==========
*/

function contractBalances()
    public
    view
    returns (uint256 eth, uint256 link)
{
    eth = address(this).balance;

    LinkTokenInterface linkContract = LinkTokenInterface(
        chainlinkTokenAddress()
    );
    link = linkContract.balanceOf(address(this));
}

function getChainlinkToken() public view returns (address) {
    return chainlinkTokenAddress();
}

function withdrawLink() public onlyOwner {
    LinkTokenInterface link = LinkTokenInterface(chainlinkTokenAddress());
    require(
        link.transfer(msg.sender, link.balanceOf(address(this))),
        "Unable to transfer Link"
    );
}

function withdrawBalance() public onlyOwner {
    payable(msg.sender).transfer(address(this).balance);
}

function cancelRequest(
    bytes32 _requestId,
    uint256 _payment,
    bytes4 _callbackFunctionId,
    uint256 _expiration
) public onlyOwner {
    cancelChainlinkRequest(
        _requestId,
        _payment,
        _callbackFunctionId,
        _expiration
    );
}

function stringToBytes32(string memory source)
    private
    pure
    returns (bytes32 result)
{
    bytes memory tempEmptyStringTest = bytes(source);
    if (tempEmptyStringTest.length == 0) {
        return 0x0;
    }

    assembly {
        // solhint-disable-line no-inline-assembly
        result := mload(add(source, 32))
    }
}

}

solidity