主页 / 问题

问题[blockchain]

Martin Hope
Sam Knight
Asked: 2022-07-16 14:21:52 +0800 CST
  • 0

为什么 PoS 不需要大的计算能力，因为那里也有数学和计算？据我理解的主题，它看起来像这样，但如果我错了，请纠正我。这是主要问题。

在工作量证明的情况下，创建新区块的奖励由第一个解决复杂数学问题的人获得，这与交易本身无关。也就是说，任务的复杂性旨在淘汰小型矿工（计算能力很小），而不是数学计算交易并验证它们。数学任务是“会计办公室”的通行证，该办公室将交易记录在“分类帐”（块）中，这就是 PoW 被认为无效的原因，因为在争夺奖励的过程中，参与者的计算能力开始增长成倍增长，而且它们仅在矿工选择时才需要。简单地说，任何人都可以写一个新的博客，一个计算器就足够了，但是网络只信任那些拥有更多计算能力的人，

在 PoS 的情况下，这种信任被授予口袋里有更多钱的人。如果你有钱，那么我们相信你。这里财富的多少决定了写入区块总数的百分比。你拥有 70% 的项目代币，你将编写 70% 的区块。在第一种和第二种情况下，都不需要用于解决写入块和检查它的问题的计算能力。如果我理解正确，我有一个问题：编写块本身需要什么计算能力，而不是容忍前奏？该任务包括什么（验证交易、从余额中减去或添加、执行函数等）？

blockchain
Martin Hope
Corle
Asked: 2022-07-26 08:16:08 +0800 CST
  • 0

我正在尝试获取 PairCreated 事件记录（https://bscscan.com/address/0xca143ce32fe78f1f7019d7d551a6402fc5350c73#events）。但是服务器正在响应我的请求{"jsonrpc":"2.0","id":1,"result":[]}。帮助正确地向 RPC 发出请求。

curl https://bsc-dataseed1.ninicoin.io/ -X POST --data '{               
    "id": 1,
    "method": "eth_getLogs",
    "jsonrpc": "2.0",
    "params": [
            {
    "address": "0xca143ce32fe78f1f7019d7d551a6402fc5350c73",
    "topics": ["0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9"]
            }
    ]}'
blockchain json-rpc
Martin Hope
Михаил Камахин
Asked: 2022-05-26 19:34:03 +0800 CST
  • 2

我参加了 IDO，使用这个智能合约为我的硬币打上了烙印 https://bscscan.com/address/0x4e62210aacc9a979e9f20e8d14bc01b01365dc32#code

我不明白如何调用构造函数，从哪里调用。感觉就像您可以在 JavaScript（或其他）中调用合约并将参数传递给构造函数。如果是这样，那么事实证明第一个参数可以传递给任何绝对标记。代码中没有检查 IERC20 代币是这个特定的代币，而不是其他
代币

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "Ownable.sol";
import "IERC20.sol";
import "ERC20.sol";
import {SafeERC20} from "SafeERC20.sol";
import {SafeMath} from "SafeMath.sol";

contract A4Sale is Ownable  {

    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    IERC20 private _token;
    IERC20 private _currency;

    uint256 public _cap;
    uint256 private _rate = 1;

    uint256 public startTime;
    uint256 public releaseTime;
    uint256 public claimTime;
    uint256 public endTime;

    uint256 private minDepositValue = 10 * 10 ** 18;
    uint256 private minWithdrawValue = 1 * 10 ** 18;
    uint256 private _unitsTotal = 0;

    mapping(address => uint256) public _deposits;

    event Deposit(address indexed, uint256 indexed, uint256 indexed);
    event Withdraw(address indexed, uint256 indexed, uint256 indexed);
    event TokenWithdrowed(address indexed, uint256 indexed);


    constructor(
        IERC20 token,
        IERC20 currency,
        uint256 cap,
        uint256 _startTime,
        uint256 _releaseTime,
        uint256 _claimTime,
        uint256 _endTime ) public
    {
        _token = token;
        _currency = currency;
        _cap = cap;

        startTime = _startTime;
        releaseTime = _releaseTime;
        claimTime = _claimTime;
        endTime = _endTime;
    }

    function rate() view public returns (uint256) {
        return _rate;
    }

    function total() view public returns (uint256) {
        return _unitsTotal;
    }

    // investor token balance 
    function balanceOf(address investor) view public returns (uint256) {
        return _deposits[investor];
    }

    function deposit( uint256 value ) public {
        _deposit(value);
    }

    function withdraw( uint256 value ) public {
        _withdraw(value);
    }

    function withdrawTokens() public {
        _withdrawTokens();
    }

    function withdrawIDO( uint256 value ) onlyOwner public {
        require(claimTime <= block.timestamp, "IDO is active");
        
        _unitsTotal = _unitsTotal.sub(value);
        IERC20(_currency).transfer(msg.sender, value);
    }

    function _deposit( uint256 value ) internal
    {
        require(startTime <= block.timestamp &&  releaseTime > block.timestamp, "IDO is stopped");
        require(value >= minDepositValue, "Not enough value");

        _deposits[msg.sender] = _deposits[msg.sender].add(value);
        _unitsTotal = _unitsTotal.add(value);

        _rate = _unitsTotal.div(_cap);

        IERC20(_currency).transferFrom(msg.sender, address(this), value);

        emit Deposit(msg.sender, value, _rate);
    }

    function _withdraw( uint256 value ) internal
    {
        require(releaseTime <= block.timestamp && claimTime > block.timestamp, "No time for withdraw");
        require(value <= _deposits[msg.sender] && value > minWithdrawValue, "Error withdraw value");

        _deposits[msg.sender] = _deposits[msg.sender].sub(value);
        _unitsTotal = _unitsTotal.sub(value);
        _rate = _unitsTotal.div(_cap);

        IERC20(_currency).transfer(msg.sender, value);

        emit Withdraw(msg.sender, value, _rate);
    }

    function _withdrawTokens() internal
    {
        require(claimTime <= block.timestamp && endTime > block.timestamp, "No time for claime");
        require(_deposits[msg.sender] > 0, "Zero tokens");

        uint256 tokens = _deposits[msg.sender].div(_rate);
        _deposits[msg.sender] = 0;

        _token.transfer(msg.sender, tokens);
        
        emit TokenWithdrowed(msg.sender, tokens);
    }

    
}
blockchain
Martin Hope
Cenzor
Asked: 2021-10-20 06:40:07 +0800 CST
  • 1

Solidity 有一个事件。

在什么情况下需要它们？他们在解决什么问题？

如果不难，请用文字举一个简单的例子。我的理解是：使用事件，你可以将某个结果写入区块链交易，然后使用 Java 代码检查是否有这样的事件。例如，在进行支付/交易时，您可以调用一个事件并向其传递 3 个参数：发件人、收件人、金额。以后，您可以在智能合约的交易日志中查看该交易是否已执行。我理解正确吗？如果是这样，如何在日志中检查此事件？

然而，当声明一个事件时，它的参数可以被标记为索引（indexed），这有什么好处，不像它们没有用索引关键字标记？谢谢你。

blockchain