精华内容
下载资源
问答
  • 使用Java和web3j开发以太坊令牌[概述]
    2020-04-11 01:30:12

    为此,我们将使用我创建的基本ERC20智能合约JavaToken,您可以在此处找到。 我们将使用它及其所在的存储库进行演示,请随时克隆它并继续学习! 我们将在上面部署和运行的网络将是使用Truffle的本地Ganache Testnet。

    我最近写了一篇有关开始使用Android进行以太坊开发的文章,其中我演示了如何在Android中设置web3j以及如何传输以太币。 发布后,我得到了一个请求,要求编写一篇有关使用web3j与自定义ERC20令牌进行交互的文章,该文章导致了本文的创建。 请享用!

    步骤0.9:生成智能合约Java包装器

    0.9步是为我们的智能合约获取一个Java包装器。 它是步骤0.9,因为从技术上讲 ,如果您的合同已经部署,则不是强制性的,但是在以后与合同进行交互时,它将使事情变得容易得多。 为此,请先使用Solidity编译器编译Solidity合同。 如果您使用的是Truffle,则只需在JavaToken存储库的Truffle目录中运行以下命令即可完成此操作:

    truffle compile

    接下来,安装web3j命令行界面。

    Mac / Linux:

    curl -L get.web3j.io | sh
    

    视窗:

    Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString( 'https://raw.githubusercontent.com/web3j/web3j-installer/master/installer.ps1' ))
    

    现在我们已经安装了所有内容,只需运行

    web3j truffle generate Truffle/build/contracts/JavaToken.json -o src -p com.javaToken
    

    从JavaToken目录中。 这将为JavaToken智能合约生成一个包装,以使其在以太坊中的交互更加容易。

    步骤1:部署合约

    为了部署令牌,我们设置了一些凭证,并简单地使用它们调用deploy()方法。

    // The Ganache TestNet listens at port 7545
    Web3j w3 = Web3j.build( new HttpService( "HTTP://127.0.0.1:7545" ));
    String privateKey = "YourPrivateKeyHere" ;
    Credentials credentials = Credentials.create(privateKey);
    // Sets the initial supply of JavaTokens in existence
    BigInteger initialSupply = BigInteger.valueOf( 100000 );
    
    JavaToken javaToken = JavaToken.deploy(w3, credentials, new DefaultGasProvider(), initialSupply).send()
      

    然后,您就部署了一个全新的以太坊令牌!

    另外,如果您的合同已经部署并且只想与之交互,则可以使用以下命令简单地加载它:

    // The Ganache TestNet listens at port 7545
    Web3j w3 = Web3j.build( new HttpService( "HTTP://127.0.0.1:7545" ));
    String privateKey = "YourPrivateKeyHere" ;
    Credentials credentials = Credentials.create(privateKey);
    String contractAddress = "YourContractAddress" ;
    
    JavaToken javaToken = JavaToken.load(contractAddress,w3,credentials, new DefaultGasProvider());

    步骤2:取得平衡

    合同配置为向其部署者提供整个初始供应。 让我们检查一下我们是否真的拥有一切。 如果我们从第0.9步开始使用包装器,这很简单:

    // With java wrapper
    BigInteger balance = javaToken.balanceOf(credentials.getAddress()).send()
    
    // Without java wrapper
    String contractAddress = "YourDeployedContractAddress" ;
    
    // Define the function we want to invoke from the smart contract
    Function function = new Function( "balanceOf" , Arrays.asList( new Address(credentials.getAddress())),
                                     Arrays.asList( new TypeReference<Uint256>() {}));
    
    // Encode it for the contract to understand
    String encodedFunction = FunctionEncoder.encode(function);
    
    /*
    Send the request and wait for the response using eth call since
    it's a read only transaction with no cost associated
    */
    EthCall response = w3.ethCall(
      Transaction.createEthCallTransaction(credentials.getAddress(), contractAddress, encodedFunction),
      DefaultBlockParameterName.LATEST).send();
    
    balance = Numeric.toBigInt(response.getValue());

    否则,它会变得更加复杂:首先,我们需要在交易中手动输入要在合约中调用的函数的详细信息,在这种情况下,它的名称是balanceOf,我们提供的参数是一个地址,我们想要该函数返回一个uint256。 然后,我们对这些数据进行编码,并将其与我们希望将其发送给和来自谁的电话(我们的地址)的合同一起放入交易中。 最后,我们将十六进制结果解码为BigInteger。

    现在,我们已经有了100.000个JavaToken。 让我们发送一些给朋友!

    第3步:转移一些令牌

    同样,拥有包装器和不具有包装器之间的区别非常明显:

    String addressTo = "YourFriendsAddress" ;
    BigInteger amount = BigInteger.valueOf( 500 );
    
    // With java wrapper
    TransactionReceipt receipt = javaToken.transfer(addressTo,amount).send();
    
    // Without java wrapper
    
    // Define the function we want to invoke from the smart contract
    Function function = new Function( "transfer" , Arrays.asList( new Address(addressTo), new Uint256(amount)),
                                     Collections.emptyList());
    
    // Encode it for the contract to understand
    String encodedFunction = FunctionEncoder.encode(function);
    
    /*
    Need to use a TransactionManager here since transfer actually alters the state of the blockchain
    and credentials are therefore relevant
    */
    TransactionManager transactionManager = new FastRawTransactionManager(w3, credentials);
    
    
    // Send the transaction off using transactionManager and wait for the hash
    String transactionHash = transactionManager.sendTransaction(DefaultGasProvider.GAS_PRICE,
                                                                DefaultGasProvider.GAS_LIMIT, contractAddress, encodedFunction,
                                                                BigInteger.ZERO).getTransactionHash();
    
    // Fetch the transaction receipt
    Optional<TransactionReceipt> transactionReceipt =
      w3.ethGetTransactionReceipt(transactionHash).send().getTransactionReceipt();
    if (transactionReceipt.isEmpty())
      receipt = null ;
    else
      receipt = transactionReceipt.get();

    这次没有包装器有点不同,因为我们需要实际证明该交易来自我们的账户,因为我们正在通过转移令牌而不是像以前那样读取数据来改变区块链的状态。

    我们以创建函数对象的相同方式开始。 尽管智能合约函数返回一个布尔值,但由于不需要它,因此在此处未指定它,因为我们正在通过交易收据检查交易是否成功,因此我们将返回值指定为一个空列表。 接下来,我们创建一个事务管理器。

    这种区别很重要,因为所说的经理将我们的凭证作为参数,这意味着通过它发送的交易将归于我们(与上面的balanceOf调用不同)。 最后,我们发送交易,并通过检查收据确认交易是否成功。

    结论

    就这样! 您刚刚学习了如何使用web3j部署自己的ERC20令牌。 恭喜你! 所有这些的代码都可以在这里找到。

    感谢您的关注!

    尼古拉斯

    如果您愿意,可以给这个故事加个掌声,让更多的人看到它!

    如果您喜欢这个,请给我买咖啡:)

    以太坊:0x190d71ba3738f43dc6075f5561e58ac9d4e3dfc2

    比特币:1BRucWzs2vnrkfmbfss14ZQErW74A1H1KE

    莱特币:LbNfoJfTFVCj7GFaAUtWqhitHJcJ3m8y3V

    (最初在此处发布)

    From: https://hackernoon.com/ethereum-token-development-using-java-and-web3j-an-overview-spas324r

    更多相关内容
  • 令牌:以太坊令牌定义
  • 您通往以太坊令牌世界的友好大门 提供API,TOP图表,以太坊代币索引,网站小部件。 通过历史余额图表和交易跟踪任何以太坊地址的投资组合。 完整的地址分析,从历史余额到每天每个令牌的交易,操作和转移量。 使用...
  • Cryptallet是一个小型应用程序,用于演示如何在Xamarin中使用以太坊和基于以太坊令牌。 该应用程序使用Xamarin.Forms,具有模块化结构的Prism构建。 关于 该项目由Naxam Co.,Ltd。维护。 我们专注于使用Xamarin和...
  • 以太坊的新高级令牌标准 该标准定义了与令牌合约进行交互的新方法。 该标准利用了 。 :warning_selector: 该代码尚未经过审核。 :warning_selector: 请检查您在令牌相关项目中使用的所有代码,包括此处提供的代码...
  • 智能合约 阿卜杜勒令牌 基于ERC-20令牌标准的以太坊令牌
  • 该存储库包含有关如何使用以下方法批量获取以太坊令牌的代码示例: GraphQL 以太网络 web3.js BatchRequest 设置您的环境 安装以下Node.js软件包: 在constant.js文件中,替换以下值以适合您的用例: ABI ...
  • 使用开放源代码合同(open-zeppelin)创建以太坊令牌 (Create an Ethereum token using open source contracts (open-zeppelin)) I want to show you that creating a best practice token is a simple p...

    zeppelin连接数据源

    by Danny

    通过丹尼

    使用开放源代码合同(open-zeppelin)创建以太坊令牌 (Create an Ethereum token using open source contracts (open-zeppelin))

    I want to show you that creating a best practice token is a simple process. To be honest, we are going to be doing some coding, but it won’t be much.

    我想向您展示创建最佳实践令牌是一个简单的过程。 老实说,我们将要进行一些编码,但是不会太多。

    We’ll be using Solidity to create our Ethereum token. But don’t worry, there are a lot of open source libraries and contracts to help us in the process.

    我们将使用Solidity创建我们的以太坊令牌。 但是不用担心,有很多开源库和合同可以在此过程中为我们提供帮助。

    What we want is an ERC-20 compliant token. What that means is that the Ethereum developers have decided a set of functionalities that is necessary for your most common token usages today. There are other types of ERC standards, but we wont dive into it.

    我们想要的是符合ERC-20的令牌。 这意味着以太坊开发人员已经决定了当今最常见的令牌使用所必需的一组功能。 还有其他类型的ERC标准,但我们不会深入探讨。

    Requirements:

    要求:

    • Github

      Github
    • Terminal

      终奌站
    • NodeJS

      节点JS
    • NPM

      NPM
    • Metamask (For initial Account Creation)

      Metamask(用于初始帐户创建)

    Alright let’s start coding! The first thing we want to do is download truffleglobally. You can visit their repo at truffle and here’s the following snippet to install:

    好吧,让我们开始编码! 我们要做的第一件事是全局下载truffle 。 您可以在松露处访问他们的存储库,以下是要安装的代码段:

    npm install -g truffle

    *note: make sure you have the latest version of truffle if you installed this prior

    *注意 :如果您事先安装了最新版的松露,请确保已安装

    Truffle will handle the smart contract compilation, linking, and deployment for us. It’s a library that will make our lives easier for this demonstration.

    松露将为我们处理智能合约的编译,链接和部署。 这是一个图书馆,可以使我们的生活更加轻松。

    Now we need to create a directory where our project will live. In my case I called it ethereum_token_tutorial.

    现在,我们需要创建一个目录,该目录将用于我们的项目。 就我而言,我将其称为ethereum_token_tutorial。

    So we have two options here. Either you can clone the repo I have created by following this:

    因此,我们在这里有两个选择。 您可以按照以下步骤克隆我创建的存储库:

    git clone -b initial_step https://git@github.com/danieljoonlee/ethereum_token_tutorial.git

    Or you can do this in your terminal inside of your new directory:

    或者,您可以在新目录内的终端中执行此操作:

    truffle init

    If you followed the second option of doing truffle init. The directory should look like this:

    如果遵循第二种选择,即truffle init 。 该目录应如下所示:

    etherem_token_tutorial|___contracts| |_____ConvertLib.sol| |_____MetaCoin.sol| |_____Migrations.sol|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test| |_____TestMetacoin.sol| |_____metacoin.js|___truffle.js

    Go ahead and delete ConvertLib.sol , MetaCoin.sol , TestMetacoin.sol , metacoin.js.

    继续并删除ConvertLib.solMetaCoin.solTestMetacoin.solmetacoin.js

    So your directory should look like this now:

    因此您的目录现在应如下所示:

    etherem_token_tutorial|___contracts| |_____Migrations.sol|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test|___truffle.js

    Great. Now we’re moving. Truffle helps us compile smart contracts and deploy them. But we deleted our smart contract files other than the migrating helper. Don’t worry, this is where Open-Zeppelin comes in.

    大。 现在我们要搬家了。 松露可帮助我们编译和部署智能合约。 但是我们删除了迁移助手以外的智能合约文件。 别担心,这是Open-Zeppelin的用武之地。

    Open-Zeppelin is an open source repo where you can find smart contracts with generally best practices, good test coverage, and most likely audited*.

    Open-Zeppelin是一个开放源代码回购,您可以在其中找到具有最佳实践,良好的测试覆盖率以及最有可能经过审计*的智能合约。

    • Audit is when you have professional developers review your smart contracts looking for any leaks, bugs, or possibilities of malicious attacks.

      审核是指让专业开发人员查看您的智能合约,以查找任何泄漏,错误或恶意攻击的可能性。

    Here’s a link if you’re interested in smart contract attacks: Link

    如果您对智能合约攻击感兴趣,请使用以下链接: 链接

    For us to use any Open-Zeppelin contracts we need to install it into our repository:

    为了让我们使用任何Open-Zeppelin合同,我们需要将其安装到我们的存储库中:

    npm init -ynpm install -E zeppelin-solidity

    We initialized a package.json with npm init -y. We also installed the package for using the Open-Zeppelin contracts.

    我们使用npm init -y初始化了package.json。 我们还安装了使用Open-Zeppelin合同的软件包。

    Okay, we’re going to write some Solidity. I did mention in the article earlier that this will not be much code and I wasn’t joking!

    好的,我们将编写一些Solidity。 我在前面的文章中确实提到过,这不会是太多代码,而且我不是在开玩笑!

    Create a new file in the contracts folder. In my case I named it TestToken.sol

    contracts文件夹中创建一个新文件。 就我而言,我将其命名为TestToken.sol

    Now your directory should look like this:

    现在您的目录应如下所示:

    etherem_token_tutorial|___contracts| |_____Migrations.sol| |_____TestToken.sol***(this one is new)|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test|___truffle.js

    In TestToken.sol we need to have the following code:

    TestToken.sol我们需要以下代码:

    // TestToken.solpragma solidity ^0.4.18;
    import "zeppelin-solidity/contracts/token/ERC20/MintableToken.sol";
    contract TestToken is MintableToken {    string public constant name = "Test Token";    string public constant symbol = "TT";    uint8 public constant decimals = 18;}

    Let’s break this down since it’s quite a bit , even though it’s only a few lines of code.

    让我们分解一下,因为它虽然很多,但只有几行代码。

    pragma solidity ^0.4.18;

    pragma solidity ^0.4.18;

    It is required at the top of the file because it specifies the version of Solidity we’re using.

    在文件顶部是必需的,因为它指定了我们正在使用的Solidity版本。

    import "zeppelin-solidity/contracts/token/ERC20/MintableToken.sol";

    The above code snippet is why Open-Zeppelin is so useful. If you know how inheritance works, our contract is inheriting from MintableToken. If you don’t know how inheritance works, MintableToken has a lot of functionalities saved in inMintableToken.sol. We can use these functionalities to create our token. If you visit this MintableToken you’ll notice a ton of functions and even more inheritance. It can be a bit of a rabbit hole, but for this demonstration purpose, I want us to release a token into the testnet.

    上面的代码段是为什么Open-Zeppelin如此有用的原因。 如果您知道继承的工作原理,那么我们的合同就是从MintableToken继承的。 如果您不知道继承的工作原理,则MintableToken在inMintableToken.sol中保存了很多功能。 我们可以使用这些功能来创建令牌。 如果您访问此MintableToken,您会注意到大量的函数甚至更多的继承。 这可能有点麻烦,但是出于演示目的,我希望我们将令牌释放到测试网中。

    For us, Mintable let’s us create as many tokens as we want, so we won’t be starting with an initial supply. In my next article, we’ll create a nodejs service that will create new tokens, and handle other ERC-20 standard functionalities.

    对于我们来说,Mintable让我们创建所需数量的令牌,因此我们不会从初始供应开始。 在我的下一篇文章中,我们将创建一个nodejs服务,该服务将创建新令牌并处理其他ERC-20标准功能。

    The next bit of code:

    下一段代码:

    contract TestToken is MintableToken {    string public constant name = "Test Token";    string public constant symbol = "TT";    uint8 public constant decimals = 18;}

    This is where we can customize the token. In my case, I named mine “Test Token”, with the symbol “TT”, and decimals of 18. But why 18 decimals?

    这是我们可以自定义令牌的地方。 在我的情况下,我将我的“ Test Token”命名为“ TT”,十进制数为18。但是为什么要18十进制数呢?

    Decimals of 18 is fairly standard in the community. So if we have one test token it can potentially look like this 1.111111111111111111.

    在社区中,小数点18是相当标准的。 因此,如果我们有一个测试令牌,它可能看起来像这样1.111111111111111111111。

    Whelp. That’s all the Solidity coding we need to do for this token. We inherit all the main functionalities for a standardized ERC 20 token from Open-Zeppelin. After that we need to set our constants for the name, symbol, and decimals.

    仔。 这就是我们需要为此令牌执行的所有Solidity编码。 我们继承了Open-Zeppelin标准化ERC 20令牌的所有主要功能。 之后,我们需要为名称,符号和小数设置常量。

    Before we forget, we should create a Metamask account and get it funded with testnet ethereum.

    在忘记之前,我们应该创建一个Metamask帐户,并使用testnet以太坊为其提供资金。

    Go ahead and search MetaMask extension for Chrome, or follow this link

    继续并搜索MetaMask于Chrome的MetaMask扩展程序,或点击此链接

    After you install MetaMask you should see a series of steps. You can read through like terms of service. Eventually you’ll reach:

    安装MetaMask后,您应该会看到一系列步骤。 您可以阅读类似的服务条款。 最终您将达到:

    Input your password and confirm that password. On clicking create, you will see another screen.

    输入您的密码并确认该密码。 单击创建时,您将看到另一个屏幕。

    Make sure to save your seed words or copy them down into a text file. We will need those seed words to deploy the token onto the testnet.

    确保保存您的种子词或将其复制到文本文件中。 我们将需要这些种子词来将令牌部署到测试网上。

    Also more important is to change your test from Mainnet Test Net to Ropsten Test net. It’s on the top left of your MetaMask tab. Here is the drop down:

    同样重要的是将您的测试从Mainnet测试网更改为Ropsten测试网。 它在您的MetaMask标签的左上方。 这是下拉列表:

    The reason we’re using Ropsten Test Network is because it’s the closest testnet/implementation of the Main Ethereum Network.

    我们使用Ropsten测试网络的原因是因为它是以太坊主网络最接近的测试网/实现。

    Next you will need to copy your address to clipboard from the ... menu like so:

    接下来,您需要将地址从...菜单复制到剪贴板,如下所示:

    You should have an address similar to this one copied to your clipboard:

    您应该将与该地址相似的地址复制到剪贴板:

    address: 0x8EeF4Fe428F8E56d2202170A0bEf62AAc93989dE

    This is the address from which we’re going to deploy our token contract. Now one thing you need to know about deploying contracts is that they cost Ethereum, to be specific Gas. We’re going to need to get some testnet Ethereum into our accounts.

    这是我们将用来部署令牌合约的地址。 现在,您需要了解的有关部署合同的一件事是,它们要花费以太坊,具体来说就是Gas。 我们将需要在账户中加入一些以太坊测试网。

    Now that you have your address go to this Ropsten faucet link:

    现在您有了地址,请转到以下Ropsten水龙头链接:

    Ethernet FaucetEdit descriptionfaucet.ropsten.be

    以太网水龙头 编辑描述 faucet.ropsten.be

    Copy and paste your address and soon you should have 1 Ethereum in your MetaMask wallet for your address.

    复制并粘贴您的地址,不久您的MetaMask钱包中应该有1个以太坊作为您的地址。

    Just one more thing before we start coding our deployment process! We’re going to use a free API called Infura.io:

    在开始对部署过程进行编码之前,还有一件事情! 我们将使用一个名为Infura.io的免费API:

    Infura — Scalable Blockchain InfrastructureSecure, reliable, and scalable access to Ethereum APIs and IPFS gateways.infura.io

    Infura —可扩展的区块链基础架构 对以太坊API和IPFS网关的安全,可靠和可扩展的访问。 信息

    Sign up for their services. You should get an email from them or be redirected to a site with your API Key. The one we want specifically is from the Ropsten Network.

    注册他们的服务。 您应该从他们那里收到电子邮件,或使用API​​密钥将其重定向到网站。 我们特别想要的是来自Ropsten网络的产品。

    Test Ethereum Network (Ropsten)https://ropsten.infura.io/API_KEY

    Copy your API_KEY.

    复制您的API_KEY。

    Almost there! Now let’s start working on our deployment. Let’s head back in our code.

    差不多了! 现在,让我们开始进行部署。 让我们回到我们的代码中。

    First things first, let’s talk about security. Create a new file in your root directory called .env. Your file structure should now look like this:

    首先,让我们谈谈安全性。 在您的根目录中创建一个名为.env的新文件。 您的文件结构现在应如下所示:

    etherem_token_tutorial|___contracts| |_____Migrations.sol| |_____TestToken.sol|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test|___truffle.js|___.env**(new file)

    Inside your .env file lets add some environmental variables (these are variables that you can access anywhere in your code directory)

    .env文件中,可以添加一些环境变量(这些变量可以在代码目录中的任何位置访问)

    //.env fileINFURA_API_KEY=API_KEYMNENOMIC=MNEOMIC_FROM_METAMASK

    First add your API_KEY you copied into the file.

    首先将您复制的API_KEY添加到文件中。

    Remember the Mneomic(seed words) from initializing Metamask chrome extension? We’re going to need that now to deploy the contracts from. If you downloaded or wrote down your Mneomic, now write them down in your .env file MNENOMIC=SOME KEY PHRASE YOU DONT WANT THE PUBLIC TO KNOW.

    还记得初始化Metamask chrome扩展时的Mneomic(种子词)吗? 我们现在需要从中部署合同。 如果您下载或记下了Mneomic,请现在将其记入.env文件中MNENOMIC=SOME KEY PHRASE YOU DONT WANT THE PUBLIC TO KNOW..env MNENOMIC=SOME KEY PHRASE YOU DONT WANT THE PUBLIC TO KNOW.

    IMPORTANT***

    重要***

    We added a .env file!!! We need to add a .gitignore file now to avoid adding the .env to a public repository if you ever decide to make the code public!

    我们添加了.env文件!!! 如果您决定公开代码,我们现在需要添加.gitignore文件,以避免将.env添加到公共存储库中!

    Create a .gitignore file in the same directory as your .env. Now it should look like this:

    在与.env相同的目录中创建一个.gitignore文件。 现在看起来应该像这样:

    etherem_token_tutorial|___contracts| |_____Migrations.sol| |_____TestToken.sol|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test|___truffle.js|___.env|___.gitignore**(newfile)

    Inside your .gitignore file:

    在您的.gitignore文件中:

    // .gitignorenode_modules/build/.env

    We want to ignore node_modules/ because when we do npm install it will download packages from our package.json. We want to ignore buildbecause later on when we run a script, it will create that directory for us automatically. We also want to ignore .env because it has private information we don’t want to release to the public.

    我们想忽略node_modules/因为在进行npm install ,它将从package.json下载软件包。 我们想忽略build因为稍后运行脚本时,它将自动为我们创建该目录。 我们也想忽略.env因为它包含我们不希望向公众发布的私人信息。

    Great! Over in our terminal we need to add two more modules.

    大! 在我们的终端中,我们需要再添加两个模块。

    npm install --save dotenv truffle-hdwallet-provider

    Since we’re putting in private information, we need a way to access those variables from .env, and the dotenv package will help us.

    由于我们要输入私人信息,因此我们需要一种从.env访问这些变量的.env ,而dotenv软件包将为我们提供帮助。

    The second package, truffle-hdwallet-provider is a wallet enabled provider. Without this, we would need to download all the blocks or use a light wallet to make new transactions in the Ethereum network. With the wallet provider and Infura API. We can deploy instantly, also bypassing painful processes.

    第二个软件包truffle-hdwallet-provider是启用了钱包的提供程序。 否则,我们将需要下载所有区块或使用轻钱包在以太坊网络中进行新交易。 使用钱包提供商和Infura API。 我们可以立即部署,也可以绕过繁琐的过程。

    Over in the truffle.js in our root directory, we need to modify some configurations.

    在根目录的truffle.js中,我们需要修改一些配置。

    // truffle.jsrequire('dotenv').config();const HDWalletProvider = require("truffle-hdwallet-provider");
    module.exports = {  networks: {    development: {      host: "localhost",      port: 7545,      gas: 6500000,      network_id: "5777"    },    ropsten: {        provider: new HDWalletProvider(process.env.MNENOMIC, "https://ropsten.infura.io/" + process.env.INFURA_API_KEY),        network_id: 3,        gas: 4500000    },  }};

    The first line indicates we want to use the .env variables in this repo. Generally in most apps, you only need to require this once in the starting config file.

    第一行表明我们要在此.env中使用.env变量。 通常,在大多数应用中,您只需在启动配置文件中要求一次。

    Most of this is boilerplate. Main section we want to focus on is the ropsten network.

    其中大部分是样板。 我们要关注的主要部分是绳索网络。

    ropsten: {        provider: new HDWalletProvider(process.env.MNENOMIC, "https://ropsten.infura.io/" + process.env.INFURA_API_KEY),        network_id: 3,        gas: 4500000    },

    The provider is our network. In our case, we want to deploy our token into the Ropsten network. Using the HDWalletProvider we pass in two arguments, process.env.MNENOMIC, "https://ropsten.infura.io/" + process.env.INFURA_API_KEY. We access our .env variables by referencing process.env.VARIABLE_NAME_IN_ENV.

    提供者是我们的网络。 在我们的案例中,我们希望将令牌部署到Ropsten网络中。 使用HDWalletProvider我们传入两个参数process.env.MNENOMIC, "https://ropsten.infura.io/" + process.env.INFURA_API_KEY 。 我们通过引用process.env.VARIABLE_NAME_IN_ENV访问我们的.env变量。

    We set the network_id: 3 because that represents Ropsten. 1 is the main Ethereum net and 2 is an old testnet.

    我们将network_id: 3设置为network_id: 3因为它表示Ropsten。 1是主要的以太坊网络, 2是旧的测试网。

    Lastly, we set gas: 4500000, which is why we needed the Ethereum originally. We use gas/ethereum any time we need to modify/add something in the Ethereum Network.

    最后,我们将gas: 4500000设置为gas: 4500000 ,这就是为什么我们最初需要以太坊的原因。 每当需要在以太坊网络中修改/添加某些内容时,我们都会使用gas/ethereum

    Alright, onto the last step before deployment!

    好了,部署前的最后一步!

    Over in our migrations/2_deploy_contract.js, we need to make some modifications for our contract.

    在我们的migrations/2_deploy_contract.js ,我们需要对合同进行一些修改。

    // 2_deploy_contract.js
    const TestToken = artifacts.require("./TestToken.sol");
    module.exports = function(deployer) {  deployer.deploy(TestToken);};

    If you named your token contract file something else. You need to replace the TestToken.sol to whatever file you named it.

    如果您将令牌合同文件命名为其他名称。 您需要将TestToken.sol替换为您命名的任何文件。

    truffle compile

    This should create a new folder in your directory:

    这应该在您的目录中创建一个新文件夹:

    etherem_token_tutorial|___build| |_____contracts|    |_____BasicToken.json|    |_____ERC20.json|    |_____ERC20Basic.json|    |_____Migrations.json|    |_____MintableToken.json|    |_____Ownable.json|    |_____SafeMath.json|    |_____StandardToken.json|    |_____TestToken.json|___contracts| |_____Migrations.sol| |_____TestToken.sol|___migrations| |_____1_initial_migrations.js| |_____2_deploy_contracts.js|___test|___truffle.js|___.env|___.gitignore**(newfile)

    In our build folder, we have a bunch of contracts we inherited from the Open-Zeppelin library. If you’d like to know more about ERC-20 standards I’d check out the wiki. If there’s enough people asking for it I can make another blog post on it. For now here’s the link to the wiki.

    在我们的build文件夹中,我们有一堆继承自Open-Zeppelin库的合同。 如果您想了解有关ERC-20标准的更多信息,请查看Wiki。 如果有足够的人要求它,我可以在上面发表另一篇博客文章。 现在,这里是Wiki的链接

    Here comes the moment of truth. Now we need to deploy the contracts into the Ropsten network. Enter the following line in your terminal:

    关键时刻到了。 现在,我们需要将合​​同部署到Ropsten网络中。 在终端中输入以下行:

    truffle migrate --network ropsten

    You should get a series of lines in your terminal like:

    您应该在终端中看到以下几行:

    Using network 'ropsten'.
    Running migration: 1_initial_migration.js  Deploying Migrations...  ... 0x7494ee96ad7db4a560b6f3169e0666c3938f9f54208f7972ab902feb049a7f68  Migrations: 0x254466c5b09f141ce1f93689db6257b92133f51aSaving successful migration to network...  ... 0xd6bc06b3bce3d15dee4b733e5d4b09f0adb8f93f75ad980bad078484641d36e5Saving artifacts...Running migration: 2_deploy_contracts.js  Deploying TestToken...  ... 0x7e5c1b37f1e509aea59cd297417efe93eb49fdab2c72fa5c37dd2c63a3ba67b7  TestToken: 0x02ec6cbd89d3a435f8805e60e2703ef6d3147f96Saving successful migration to network...  ... 0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24e2014b088a34eSaving artifacts...

    This will take some time. Once it’s fully deployed copy the last txid. In my case:

    这将需要一些时间。 完全部署后,复制最后一个txid。 就我而言:

    0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24e2014b088a34e

    This will have an address to your token contract. Here is a link to my txid:

    这将有您的令牌合同的地址。 这是我的txid的链接:

    Ropsten Transaction 0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24e2014b088a34eRopsten (ETH) detailed transaction info for 0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24e2014b088a34eropsten.etherscan.io

    Ropsten交易0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24e2014b088a34e Ropsten(ETH)详细的交易信息(0x2fd6d699295d371ffd24aed815a13c5a44e01b62ca7dc6c9c24eropstenio

    Which has an address to the contract itself:

    其中包含合同本身的地址:

    Ropsten Accounts, Address and ContractsThe Ethereum BlockChain Explorer, API and Analytics Platformropsten.etherscan.io

    Ropsten账户,地址和合约 以太坊区块链浏览器,API和分析平台 ropsten.etherscan.io

    You can get the completed github repo here.

    您可以在此处获取完整的github存储库。

    This part one of a series of creating a token and interacting with it. In the next blog we will create a simple node microservice. We will use this service to call various functions on your token smart contract, such as minting new tokens, transferring, etc.

    创建令牌并与之交互的一系列步骤之一。 在下一个博客中,我们将创建一个简单的节点微服务。 我们将使用此服务在您的令牌智能合约上调用各种功能,例如铸造新令牌,转让等。

    If you find any mistakes or typos please let me know! Also I’m always looking for exciting projects in the blockchain space.

    如果您发现任何错误或错别字,请告诉我! 另外,我一直在寻找在区块链领域令人兴奋的项目。

    If you found this helpful and feel like buying me a beer:

    如果您觉得这有帮助,并且想给我买啤酒:

    BTC: 3Kxz6zPweuiaVG28W78pX9DoEZVkLhH4nT

    BTC:3Kxz6zPweuiaVG28W78pX9DoEZVkLhH4nT

    BCH: qqwusc2peyvlh3wgl0tpt3ll4ug9zujfvy9586tgd4

    BCH:qqwusc2peyvlh3wgl0tpt3ll4ug9zujfvy9586tgd4

    ETH: 0x96Ee87e22D899BDc27EAD4fE3FCA8e9F39176B4C

    ETH:0x96Ee87e22D899BDc27EAD4fE3FCA8e9F39176B4C

    LTC: MDhqUBtGgVZrDG7TYzzyK2a2b99sHyHaQQ

    LTC:MDhqUBtGgVZrDG7TYzzyK2a2b99sHyHaQQ

    翻译自: https://www.freecodecamp.org/news/create-an-ethereum-token-using-open-source-contracts-open-zeppelin-1e132e6233ed/

    zeppelin连接数据源

    展开全文
  • solidity-erc20-token-bootstrap 您可以使用官方的以太坊客户端发布它。 俄语教程可在。
  • 以前在以太坊网络中,需要额外的工具才能一次传输许多ERC20令牌。 许多人仍然手动执行此操作,一次完成一次事务。 该过程很耗时并且容易出错。 解: 该Dapp允许用户以非常有效的方式发送成千上万个令牌传输,方法...
  • web3j以太坊开发详解 为此,我们将使用我创建的名为JavaToken的基本ERC20智能合约,您可以在此处找到。 我们将使用它及其所在的存储库进行演示,请随时克隆它并继续学习! 我们将在上面部署和运行的网络将是使用...

    web3j以太坊开发详解

    为此,我们将使用我创建的名为JavaToken的基本ERC20智能合约,您可以在此处找到。 我们将使用它及其所在的存储库进行演示,请随时克隆它并继续学习! 我们将在上面部署和运行的网络将是使用Truffle的本地Ganache Testnet。

    我最近写了一篇有关开始使用Android进行以太坊开发的文章,其中我演示了如何在Android中设置web3j以及如何传输以太币。 发布后,我得到一个请求,要求写一篇有关使用web3j与自定义ERC20令牌进行交互的文章,该文章导致了本文的创建。 请享用!

    步骤0.9:生成智能合约Java包装器

    0.9步是为我们的智能合约获取一个Java包装器。 这是步骤0.9,因为从技术上讲 ,如果您的合同已经部署,这不是强制性的,但是在以后与合同进行交互时,它将使事情变得容易得多。 为此,请先使用Solidity编译器编译Solidity合同。 如果您使用的是Truffle,则只需在JavaToken存储库的Truffle目录中运行以下命令即可完成此操作:

    truffle compile

    接下来,安装web3j命令行界面。

    Mac / Linux:

    curl -L get.web3j.io | sh

    视窗:

    Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/web3j/web3j-installer/master/installer.ps1' ))
    

    现在我们已经安装了所有内容,只需运行

    web3j truffle generate Truffle/build/contracts/JavaToken.json -o src -p com.javaToken

    从JavaToken目录中。 这将为JavaToken智能合约生成一个包装,以使其在以太坊中的交互更加容易。

    步骤1:部署合约

    为了部署令牌,我们设置了一些凭据,并简单地使用它们调用deploy()方法。

    // The Ganache TestNet listens at port 7545
    Web3j w3 = Web3j.build( new HttpService( "HTTP://127.0.0.1:7545" ));
    String privateKey = "YourPrivateKeyHere" ;
    Credentials credentials = Credentials.create(privateKey);
    // Sets the initial supply of JavaTokens in existence
    BigInteger initialSupply = BigInteger.valueOf( 100000 );
    
    JavaToken javaToken = JavaToken.deploy(w3, credentials, new DefaultGasProvider(), initialSupply).send()
      

    然后,您就部署了一个全新的以太坊令牌!

    另外,如果您的合同已经部署并且只想与之交互,则可以使用以下命令简单地加载它:

    // The Ganache TestNet listens at port 7545
    Web3j w3 = Web3j.build( new HttpService( "HTTP://127.0.0.1:7545" ));
    String privateKey = "YourPrivateKeyHere" ;
    Credentials credentials = Credentials.create(privateKey);
    String contractAddress = "YourContractAddress" ;
    
    JavaToken javaToken = JavaToken.load(contractAddress,w3,credentials, new DefaultGasProvider());

    步骤2:取得平衡

    合同配置为向其部署者提供整个初始供应。 让我们检查一下我们是否真的拥有一切。 如果我们有0.9步中的包装器,这很简单:

    // With java wrapper
    BigInteger balance = javaToken.balanceOf(credentials.getAddress()).send()
    
    // Without java wrapper
    String contractAddress = "YourDeployedContractAddress" ;
    
    // Define the function we want to invoke from the smart contract
    Function function = new Function( "balanceOf" , Arrays.asList( new Address(credentials.getAddress())),
                                     Arrays.asList( new TypeReference<Uint256>() {}));
    
    // Encode it for the contract to understand
    String encodedFunction = FunctionEncoder.encode(function);
    
    /*
    Send the request and wait for the response using eth call since
    it's a read only transaction with no cost associated
    */
    EthCall response = w3.ethCall(
      Transaction.createEthCallTransaction(credentials.getAddress(), contractAddress, encodedFunction),
      DefaultBlockParameterName.LATEST).send();
    
    balance = Numeric.toBigInt(response.getValue());

    否则,情况会更加复杂:首先,我们需要在交易中手动输入要在合约中调用的函数的详细信息,在这种情况下,它的名称是balanceOf,我们提供的参数是地址,我们想要该函数返回一个uint256。 然后,我们对这些数据进行编码,并将其与我们希望将其发送给和来自谁的电话(我们的地址)的合同一起放入交易中。 最后,我们将十六进制结果解码为BigInteger。

    现在,我们已经有了100.000个JavaToken。 让我们发送一些给朋友!

    第3步:转移一些令牌

    同样,拥有包装器和不具有包装器之间的区别非常明显:

    String addressTo ="YourFriendsAddress" ;
    BigInteger amount = BigInteger.valueOf( 500 );
    
    // With java wrapper
    TransactionReceipt receipt = javaToken.transfer(addressTo,amount).send();
    
    // Without java wrapper
    
    // Define the function we want to invoke from the smart contract
    Function function = new Function( "transfer" , Arrays.asList( new Address(addressTo), new Uint256(amount)),
                                     Collections.emptyList());
    
    // Encode it for the contract to understand
    String encodedFunction = FunctionEncoder.encode(function);
    
    /*
    Need to use a TransactionManager here since transfer actually alters the state of the blockchain
    and credentials are therefore relevant
    */
    TransactionManager transactionManager = new FastRawTransactionManager(w3, credentials);
    
    
    // Send the transaction off using transactionManager and wait for the hash
    String transactionHash = transactionManager.sendTransaction(DefaultGasProvider.GAS_PRICE,
                                                                DefaultGasProvider.GAS_LIMIT, contractAddress, encodedFunction,
                                                                BigInteger.ZERO).getTransactionHash();
    
    // Fetch the transaction receipt
    Optional<TransactionReceipt> transactionReceipt =
      w3.ethGetTransactionReceipt(transactionHash).send().getTransactionReceipt();
    if (transactionReceipt.isEmpty())
      receipt = null ;
    else
      receipt = transactionReceipt.get();

    这次没有包装器有点不同,因为我们需要实际证明这笔交易来自我们的账户,因为我们通过转移令牌而不是像以前那样读取数据来改变区块链的状态。

    我们以创建函数对象的相同方式开始。 尽管智能合约函数返回一个布尔值,但由于不需要它,因此此处未指定它,因为我们正在通过交易收据检查交易是否成功,因此我们将返回值指定为一个空列表。 接下来,我们创建一个事务管理器。

    这种区别很重要,因为所说的经理将我们的凭证作为参数,这意味着通过它发送的交易被归于我们(与上面的balanceOf调用不同)。 最后,我们发送交易,并通过检查收据确认交易是否成功。

    结论

    就这样! 您刚刚学习了如何使用web3j部署自己的ERC20令牌。 恭喜你! 所有这些的代码都可以在这里找到。

    感谢您的关注!

    尼古拉斯

    如果您愿意,可以给这个故事加个掌声,让更多的人看到它!

    如果您喜欢这个,请给我买咖啡:)

    以太坊:0x190d71ba3738f43dc6075f5561e58ac9d4e3dfc2

    比特币:1BRucWzs2vnrkfmbfss14ZQErW74A1H1KE

    莱特币:LbNfoJfTFVCj7GFaAUtWqhitHJcJ3m8y3V

    (最初在此处发布)

    翻译自: https://hackernoon.com/ethereum-token-development-using-java-and-web3j-an-overview-spas324r

    web3j以太坊开发详解

    展开全文
  • Create React App入门 该项目是通过。 npm start 在开发模式下运行应用程序。 打开在浏览器中查看。 如果进行编辑,页面将重新加载。 您还将在控制台中看到任何棉绒错误。 ...使用钩子构建,这是当前React的最佳实践...
  • 以太坊 erc20Editor Note: This article is for informational and entertainment purposes only and is not intended as financial advice. 编者注:本文仅用于提供信息和娱乐目的,不作为财务建议。 Hi there! It...

    以太坊 erc20

    Editor Note: This article is for informational and entertainment purposes only and is not intended as financial advice.

    编者注:本文仅用于提供信息和娱乐目的,不作为财务建议。

    Hi there! It’s been a while now since I wanted to create some projects around blockchain, and I have lately been playing around with Ethereum and how to develop smart contracts using the Solidity programming language. Today I want to share with you what was my first project, the creation, and deployment of an ERC20 token.

    嗨,您好! 自从我想围绕区块链创建一些项目以来已经有一段时间了,最​​近我一直在研究以太坊以及如何使用Solidity编程语言开发智能合约。 今天,我想与您分享我的第一个项目,即ERC20令牌的创建和部署。

    In this article, we will provide the code for a simple cryptocurrency as well as all the steps that are necessary to get your token up and running on the Ethereum network. For those interested in a more visual experience, I recorded a full session explaining all the contents of this article and doing the programming and deployment live. You can watch the view here:

    在本文中,我们将提供一种简单的加密货币的代码以及在以太坊网络上启动和运行令牌所需的所有步骤。 对于那些对更直观的体验感兴趣的人,我录制了一个完整的会话,解释了本文的所有内容,并实时进行了编程和部署。 您可以在此处观看视图:

    Live Code Stream on Youtube. 实时代码流

    Let’s get started!

    让我们开始吧!

    要求 (Requirements)

    There are a few things that we need to prepare in advance before creating our token and are described below.

    在创建令牌之前,我们需要提前准备一些事情,下面将对其进行介绍。

    选择您的以太坊网络 (Select your Ethereum network)

    You probably know Ethereum and its network, however, did you know that there are multiple instances of Ethereum running? Most people are familiar with the main Ethereum network, where all the transactions are running, and where all exchanges operate (or at least should). But there’s more to it, there are alternative networks running the same code as the main instance for example for testing purposes. An example of this is the “Ropsten Test Network” which we will be using today to deploy our code.

    您可能知道以太坊及其网络,但是,您是否知道有多个以太坊实例在运行? 大多数人都熟悉以太坊主网络,那里所有交易都在运行,所有交易所都在(或者至少应该)运行。 除此之外,还有其他网络与主要实例运行相同的代码,例如用于测试。 一个例子就是“ Ropsten测试网络”,我们今天将使用它来部署我们的代码。

    One of the benefits of using a test network is that, not only we can submit any code we want and test it out, but also we can do it free of charge. Every time a new token is created, it is necessary to register a transaction on the Ethereum network it is running. And this transaction will come with a GAS fee which we will need to pay with Ethereum from the network.

    使用测试网络的好处之一是,我们不仅可以提交所需的任何代码并对其进行测试,而且还可以免费进行。 每次创建新令牌时,有必要在正在运行的以太坊网络上注册交易。 这项交易将附带GAS费用,我们需要通过网络与以太坊支付。

    If we are on the main network of Ethereum, we would have to use actual money, like EUR or USD, to buy Ethereum first, and then create our token. Not very convenient to just try it out. However, the beauty of the test network is that we can get free Ethereum using applications called faucets. Now, this is just fake ETH, so we can’t sell them to anyone or anything, but it’s good enough to deploy our test tokens.

    如果我们在以太坊的主要网络上,我们将不得不使用实际货币(例如欧元或美元)先购买以太坊,然后创建我们的代币。 尝试一下不是很方便。 但是,测试网络的优点在于,我们可以使用名为faucets的应用程序免费获得以太坊。 现在,这只是虚假的ETH,因此我们不能将其出售给任何人或任何东西,但是足以部署我们的测试令牌。

    钱包和账户 (Wallet & Account)

    Now that we know which network we want to use to build and deploy our token, we need to create a wallet and an account into that network. I strongly recommend that you use MetaMask for this task.

    现在我们知道我们要使用哪个网络来构建和部署令牌,我们需要在该网络中创建一个钱包和一个帐户。 我强烈建议您将MetaMask用于此任务。

    MetaMask is an extension that runs as an extension on your browser and allows you to create accounts in multiple networks and it has integrations with the deployment interfaces we are going to be using today, making the job much easier than with any other method. So download MetaMask and set it up on your browser creating an account on the Ropsten Test Network. This process is super easy and guided, so I won’t get into many details.

    MetaMask是一个扩展程序,可以在您的浏览器上运行,并允许您在多个网络中创建帐户,并且与我们今天将要使用的部署界面集成在一起,这使工作比其他任何方法都容易得多。 因此,请下载MetaMask并在浏览器中进行设置,以在Ropsten测试网络上创建一个帐户。 此过程非常简单且易于指导,因此我不会涉及很多细节。

    Next, you will need some fake ETH in your account. For that, you need to run an application called “faucet.” You can use a faucet from MetaMask itself, it’s super easy and it will connect your account automatically and will send you one ETH.

    接下来,您的帐户中将需要一些虚假的ETH。 为此,您需要运行一个名为“水龙头”的应用程序。 您可以使用MetaMask本身的水龙头,它非常简单,它将自动连接您的帐户并向您发送一个ETH。

    Alternatively, you can simply google “Ethereum Faucet” and select one of the hundreds out there. Normally they will ask you for your account number (public) and with only that information they will transfer you X amount of ETH, normally one, which is more than enough for our purposes.

    或者,您可以简单地用Google搜寻“以太坊水龙头”,然后从那里选择数百种水龙头之一。 通常,他们会要求您提供您的帐号(公开),仅凭这些信息,他们就会向您转移X倍的ETH,通常是一个,对于我们的目的而言,这绰绰有余。

    代币信息 (Token Information)

    Next, we need to think about the cryptocurrency we want to create and what properties it will have. You will need the following information before we actually get started:

    接下来,我们需要考虑我们要创建的加密货币及其将具有的属性。 在实际开始之前,您将需要以下信息:

    • Token Symbol: This is an identifier for the token, for example, the token for Bitcoin is BTC. You can use from three to five alphanumeric characters for the selection.

      令牌符号:这是令牌的标识符,例如,比特币的令牌是BTC。 您可以使用三到五个字母数字字符进行选择。
    • Token Name: e.g. Bitcoin or LCS Token

      令牌名称:例如比特币或LCS令牌
    • Total Supply: How many tokens do we want to be created in total

      总供应量:我们希望总共创建多少个代币
    • Decimals: How many decimals you can use to break a token, e.g. “0” decimals makes the token binary, either you have a token or you don’t. “2” decimals allows you to fraction a token, being the smaller size 0.01; and you can add up to “18” decimals.

      小数:可以使用多少个小数来破坏令牌,例如,“ 0”小数使令牌成为二进制,无论您有令牌还是没有令牌。 “ 2”位小数允许您对令牌进行分数分割,较小的值是0.01; 并且您最多可以添加“ 18”个小数。
    • Owner Account: Account in the same network as the token which will receive the tokens upon creation. It can be the same account as the account used to pay for the GAS fee, as we will do in our example below.

      所有者帐户:与令牌位于同一网络中的帐户,创建后将接收令牌。 该帐户可以与用于支付GAS费用的帐户相同,就像我们在下面的示例中所做的那样。

    (Code)

    Last but not least, you will need to code which will run our own cryptocurrency. I’ve already prepared for you a sample code that will implement the ERC20 specification and will give you basic cryptocurrency functionality.

    最后但并非最不重要的一点是,您将需要运行自己的加密货币的代码。 我已经为您准备了一个示例代码,它将实现ERC20规范并为您提供基本的加密货币功能。

    You can download the code here:

    您可以在此处下载代码:

    更新代码 (Updating the Code)

    The first thing you need to do is to update the code, you can either download the file I provided or copy and paste the contents in your favorite text/code editor. Once there you will notice at the beginning of the file something like:

    您需要做的第一件事就是更新代码,您可以下载我提供的文件,也可以将内容复制并粘贴到您喜欢的文本/代码编辑器中。 到达该位置后,您会在文件开头注意到以下内容:

    pragma solidity ^0.4.24;// ----------------------------------------------------------------------------
    // Sample token contract
    //
    // Symbol : {{Token Symbol}}
    // Name : {{Token Name}}
    // Total supply : {{Total Supply}}
    // Decimals : {{Decimals}}
    // Owner Account : {{Owner Account}}
    //
    // Enjoy.
    //
    // (c) by Juan Cruz Martinez 2020. MIT Licence.
    // ----------------------------------------------------------------------------

    The first line of code is simply required to run any solidity program, but the rest is where it gets interesting. Though it’s actually all commented code, meaning that it has no relevance during execution or compilation, it does contain the variables we discussed we needed before we can actually deploy to the network.

    运行任何Solidity程序仅需要第一行代码,而其余的则很有趣。 尽管它实际上是所有注释的代码,这意味着它在执行或编译期间不相关,但是它确实包含我们在实际部署到网络之前讨论过的变量。

    What I did to facilitate how to work with the code, is that each of these variables needs to be assigned a value, and once they are all completed, you will have the code ready and this comment section will be a nice description of our token.

    我为促进如何使用代码所做的工作是,需要为每个变量分配一个值,一旦它们全部完成,您便已准备好代码,并且此注释部分将很好地描述我们的令牌。

    So, how do we go about updating it? For each variable, I assigned a code wrapped in {{ }}. You need to find and replace all occurrences with each one of them. This is very easy to do in any code editor.

    那么,我们如何进行更新呢? 对于每个变量,我分配了一个包装在{{ }}的代码。 您需要查找并替换所有出现的事件。 这在任何代码编辑器中都很容易做到。

    Let’s start with an example, find and replace all occurrences of {{Token Symbol}} for your token symbol, in my case: LCSTK, no need for quotes here. After replacing it should now look like this:

    让我们从一个示例开始,找到并替换所有出现的{{Token Symbol}}作为您的令牌符号,在我的例子中:LCSTK,这里不需要引号。 更换后,它现在应如下所示:

    pragma solidity ^0.4.24;// ----------------------------------------------------------------------------
    // Sample token contract
    //
    // Symbol : LCSTK
    // Name : {{Token Name}}
    // Total supply : {{Total Supply}}
    // Decimals : {{Decimals}}
    // Owner Account : {{Owner Account}}
    //
    // Enjoy.
    //
    // (c) by Juan Cruz Martinez 2020. MIT Licence.
    // ----------------------------------------------------------------------------

    And please do the same for the token name.

    并且请对令牌名称执行相同的操作。

    Next, we need to specify the total supply and the decimals, which go hand in hand. You may be wondering why. Let’s assume an example to explain. Let’s say we want to create a binary token, either I have a token or I don’t, but I can’t have 0.5 of a token, and we also want a total of 1,000 tokens to be created. Then our variables would be replaced as follows:

    接下来,我们需要指定总供应量和小数点,两者相辅相成。 您可能想知道为什么。 让我们假设一个例子来解释。 假设我们要创建一个二进制令牌,要么我有一个令牌,要么没有令牌,但是我不能有0.5个令牌,并且我们还希望创建总共1000个令牌。 然后我们的变量将被替换如下:

    Total Supply: 1000
    Decimals: 0

    However if we want to have some decimals, say two, then we would need to modify the total supply, by adding a zero for each decimal at the end of the desired number. Meaning that if we wanted 1,000 to be the total supply, we need to update our code to be 100,000 (1,000 + 00), let’s see how it looks like now:

    但是,如果我们想要一些小数,例如两个,那么我们将需要修改总供给量,即在所需数字的末尾为每个小数添加一个零。 这意味着如果我们希望总供应量为1,000,则需要将代码更新为100,000(1,000 + 00),让我们看一下现在的样子:

    // ----------------------------------------------------------------------------
    // Sample token contract
    //
    // Symbol : LCSTK
    // Name : Live Code Stream Token
    // Total supply : 100000
    // Decimals : 2
    // Owner Account : {{Owner Account}}
    //
    // Enjoy.
    //
    // (c) by Juan Cruz Martinez 2020. MIT Licence.
    // ----------------------------------------------------------------------------

    Awesome, we are almost there. We now only need to specify the account which will receive all the tokens that get created. Head to MetaMask and copy your account number, and once more, find and replace the variable in all occurrences. At the end your code should look like this:

    太好了,我们快到了。 现在,我们只需要指定一个帐户即可接收所有创建的令牌。 转到MetaMask并复制您的帐号,然后再次查找并替换所有出现的变量。 最后,您的代码应如下所示:

    // ----------------------------------------------------------------------------
    // Sample token contract
    //
    // Symbol : LCSTK
    // Name : Live Code Stream Token
    // Total supply : 100000
    // Decimals : 2
    // Owner Account : 0x6009f738dcF7194EfddDfc3B13Ce325e21A05175
    //
    // Enjoy.
    //
    // (c) by Juan Cruz Martinez 2020. MIT Licence.
    // ----------------------------------------------------------------------------

    NOTE: It is very important that you use “find and replace all occurrences” or you will have compile errors later in the process. Our file is now ready for deployment, it’s that easy!

    注意:使用“查找并替换所有出现的内容”非常重要,否则过程稍后将出现编译错误。 我们的文件现在可以部署了,就这么简单!

    部署方式 (Deployment)

    The good people from Ethereum provide us with an IDE (integrated development environment) that is fully capable of handling the full process, from editing the files, building, and deploying, among many other things.

    以太坊的优秀人才为我们提供了一个IDE(集成开发环境),该IDE完全能够处理整个过程,包括编辑文件,构建和部署等。

    This IDE named “Remix” can be accessed easily through the browser. Once there you will see a screen like the following:

    可以通过浏览器轻松访问名为“ Remix”的IDE。 到达那里后,您将看到如下屏幕:

    Image for post
    Remix Homepage
    混音首页

    The first section we see on the left is our contextual menu, and in the right section, we see the welcome screen. As we are by default on the file explorer the contextual menu shows all the files and folders that are available.

    我们在左侧看到的第一部分是上下文菜单,在右侧部分,我们看到了欢迎屏幕。 正如我们默认在文件浏览器中一样,上下文菜单显示所有可用的文件和文件夹。

    You will need to create a new file here by clicking on the “+” button near the “browser” folder on the left panel. There are already a few files in there now, but you can ignore them. You can name the file to your likes, it’s not relevant for the process.

    您需要在此处通过单击左侧面板上“浏览器”文件夹附近的“ +”按钮来创建一个新文件。 现在已经有一些文件了,但是您可以忽略它们。 您可以按自己的喜好命名文件,该文件与该过程无关。

    Once the file is created, simply pass the code that we worked on your text editor. It should look like this:

    创建文件后,只需传递我们在文本编辑器上使用的代码即可。 它看起来应该像这样:

    Image for post
    Remix File Explorer
    混音文件资源管理器

    Our code is now ready to be compiled. For that, look at the icon bar on the left of the corner. Right now we are on the first icon “File Explorer” but we need to open the second tab “Solidity Compiler”

    我们的代码现在可以编译了。 为此,请查看角落左侧的图标栏。 现在,我们在第一个图标“文件资源管理器”上,但是我们需要打开第二个选项卡“ Solidity Compiler”

    Image for post
    Remix Solidity Compiler
    Remix Solidity编译器

    Once there hit “Compile” and if all is good, you should see some options appearing in the contract drop downfield, one of them being your token contract. (Token Symbol + “Token”)

    一旦出现“ Compile”,如果一切顺利,您应该会看到一些选项出现在合约掉落场中,其中之一就是您的代币合约。 (令牌符号+“令牌”)

    With everything looking good we just need to deploy the code, head now to the fourth tab on the menu “Deploy & Run Transactions.”

    一切看起来都很好,我们只需要部署代码,现在转到菜单“ Deploy&Run Transactions”上的第四个选项卡。

    Image for post
    Remix Deploy & Run Transactions
    混合部署和运行事务

    There are here a few things we need to change before we actually hit “Deploy.” The first is, as we are using MetaMask, we need to change the “Environment” from “JavaScript VM” to “Injected Weg3.”

    在实际点击“部署”之前,我们需要更改一些内容。 首先是,因为我们正在使用MetaMask,所以我们需要将“环境”从“ JavaScript VM”更改为“ Injected Weg3”。

    The moment you do that, MetaMask will prompt you to confirm that you want to connect your MetaMask wallet to Remix, hit confirm. After you do that, your account will automatically populate the “Account” filed below with the account number and your current balance in ether.

    当您这样做时,MetaMask将提示您确认您要将MetaMask钱包连接到Remix,然后单击确认。 完成此操作后,您的帐户将自动使用下面的帐号和您当前的余额(以太币)填充下面提交的“帐户”。

    Lastly, we need to specify we want to deploy, make sure you select your contract from the “Contract” dropdown field. Your token contract is your token symbol + “Token.” Last, hit “Deploy.”

    最后,我们需要指定我们要部署的内容,请确保您从“合同”下拉字段中选择合同。 您的代币合约是您的代币符号+“代币”。 最后,点击“部署”。

    The deployment process may take anywhere from a few minutes to up to who knows how many minutes depending on the status of the network at that time. Usually, I found that Ropsten will take two to three minutes, and the maximum wait time I had was ten minutes. After the process is complete you will receive a confirmation on the screen with the information of your deployed contract, including the address where the code got saved.

    部署过程可能要花费几分钟到几分钟,直到谁知道多少分钟,这取决于当时的网络状态。 通常,我发现Ropsten将花费两到三分钟,而我的最长等待时间是十分钟。 该过程完成后,您将在屏幕上收到确认,其中包含已部署合同的信息,包括保存代码的地址。

    That’s it! Your token is now live. But how do you see it?

    而已! 您的令牌现已生效。 但是你怎么看呢?

    配置MetaMask以检索我的令牌 (Configuring MetaMask to retrieve my token)

    Up to this point, our token already exists in the Ethereum network and can be used to transact, however, how do you access your tokens? Turns out that MetaMask as well as other wallets can already operate with your token as it follows a specification called ERC20.

    到目前为止,我们的令牌已经存在于以太坊网络中并且可以用于交易,但是,您如何访问令牌? 事实证明,MetaMask和其他钱包已经可以使用您的令牌运行,因为它遵循名为ERC20的规范。

    However, wallets are not yet aware of the existence of your token, so you will have to manually add them. Let’s see how that works on MetaMask, but before we leave Remix, there’s one last thing we need to do.

    但是,钱包尚不知道令牌的存在,因此您必须手动添加它们。 让我们看看它在MetaMask上如何工作,但是在离开Remix之前,我们需要做的最后一件事。

    When the deployment process completed we ended up with a screen like this:

    部署过程完成后,我们看到了如下屏幕:

    Image for post
    Remix Deployed Contract
    混音已部署合同

    With a section called “Deployed Contracts” and right bellow our token contract information. One important data on that screen is the address where the code was deployed, please copy that using the copy icon on the right, highlighted in the picture above.

    在“部署的合同”部分中,右下方列出了我们的令牌合同信息。 该屏幕上的一个重要数据是代码的部署地址,请使用右图的复制图标复制该地址,如上图所示。

    And with that code open MetaMask, and click on “Add Token.” This will pop up a screen with two tabs, switch to the second tab called “Custom Token” and paste the address you copied in the contract address field. This will automatically populate the token symbol and decimals fields.

    并用该代码打开MetaMask,然后单击“添加令牌”。 这将弹出一个包含两个标签的屏幕,切换到第二个名为“自定义令牌”的标签,然后将您复制的地址粘贴到合同地址字段中。 这将自动填充令牌符号和小数字段。

    After that click “Next” then “Add’ and you are done. You can now see your tokens on your MetaMask wallet.

    之后,单击“下一步”,然后单击“添加”,完成操作。 现在,您可以在MetaMask钱包中看到令牌。

    结论 (Conclusions)

    Today we learned how to build and deploy your own cryptocurrency by following the ERC20 interface and utilizing Remix and MetaMask. The process is super easy, and the code we provided though working is just a minimal example. You can build many great things on top of what we did today, and I hope I can hear from you all the great projects that you build using the power of blockchain.

    今天,我们学习了如何通过遵循ERC20接口并利用Remix和MetaMask来构建和部署自己的加密货币。 该过程非常容易,我们通过工作提供的代码只是一个最小的示例。 您可以在我们今天所做的事情的基础上构建许多伟大的事物,希望我能从您那里听到您使用区块链的力量构建的所有伟大项目。

    Thanks for reading!

    谢谢阅读!

    翻译自: https://medium.com/better-programming/create-and-deploy-your-own-erc-20-token-on-the-ethereum-network-87931fe4db20

    以太坊 erc20

    展开全文
  • 该存储库维护了以太坊ERC-1155令牌标准的安全,高效和符合标准的实现。 该实现是在Horizo​​n Blockchain Games参与的共同创作期间创建的,自发布以来, , 和其他许多项目都在使用该实现。 ERC-1155令牌标准包含...
  • 在https://ethfaction.github.io/erc20_tokens/<network>/<data>上执行GET请求,以GET以太坊网络上所有ERC20令牌的合并json数据。 发出/拉动请求以添加任何丢失的令牌详细信息 示例API: 主网 GET ...
  • 以太坊/ RSK桥,允许将ERC20令牌从一个链移动到另一个链。 基本原理 跨链事件在加密的未来非常重要。 在网络之间交换令牌使令牌持有者可以在自己喜欢的链中使用令牌,而不必局限于合同所有者的网络选择。 此外,这还...
  • 以名称表示的以太坊令牌地址的代码完成。 将鼠标悬停在令牌地址上可获得实时数据,包括价格,市值和每日交易量。 以太坊地址的代码镜头,以及用于主网和测试网的Etherscan链接。 将鼠标悬停在以太坊地址上以获取...
  • NFT-StarNotary:在以太坊中创建不可替代令牌(NFT)的实践!
  • 以太坊区块链的虚拟令牌实现
  • 已弃用:移至
  • erc20-burn-relay,下一代 安装 克隆此存储库,并使用yarn install --prod设置依赖yarn install --prod 。 配置 使用您的配置,在根目录下(更确切地说,在package.json旁边)创建一个.env文件。...
  • 以太坊的重要应用是在它上面用智能合约发行通证。在白皮书中,维塔利克(人称“V神”)详细地讨论了所谓的“Token 系统”。 他的讨论可以引导我们去思考:在区块链上,通证可以表示何种价值或资产?如何用通证来表示...
  • 以太魂 以太坊主网上的人类灵魂 关于该项目 EtherSouls是一个NFT可收集项目,您... 该功能可以由每个以太坊地址执行一次,并将铸造相应的SOUL令牌。 该地址将是新铸造令牌的所有者。 合约地址: 团队 由创建的项目。
  • Moon Wallet后端模块 这是支持的后端模块 :red_heart: 和 :hot_beverage: 用于secret社区的 该后端模块可用于构建典型的ETH和ERC-20令牌钱包。...Web3JS-与以太坊客户端的交互。 后端支持任何符合JSO
  • 公开交易网络令牌 开放交易网络(OTN)–第一个提供跨链技术的平台,以团结所有区块链网络和市场参与者,并确保他们的最大利益。
  • zknifty :以太坊上不可替代代币的零知识交易 zknifty是使用零知识Merkle树证明的实现来促进以太坊上不可替代代币的批量交易的实验。 它是一个hack。 这项工作受到强烈启发和影响。 这个怎么运作 默克尔树可导致智能...
  • OCEtokenContract即将推出 OCE erc20在以太坊网络上的实现。
  • JustaDuel:以太坊游戏

    2021-03-31 10:03:48
    以太坊游戏(#ChainlinkHackathon2021) 灵感来自yu-gi-oh(经典动漫) 概括 根据硬币的价格变化(使用Chainlink提价预言机)而不是随机性来打印自己的卡。 如果您擅长于价格预测,则将获得功能强大的卡。 不同...
  • 以太坊应用

    千次阅读 2022-03-21 09:52:00
    DApp至少由以下组成: 区块链上的智能合约 Web前端用户界面 以太坊应用实现 基于以太坊创建新的加密货币(CryptoCurrency),这是2017年各种ICO泛滥的原因 基于以太坊创建域名注册系统、博彩系统 基于以太坊开发去...
  • 以太坊dapp是什么In the cryptoverse, a lot of attention is laid on Bitcoin. But don't let that overshadow the growing interest in Ethereum, which is revolutionizing the way we think of applications. 在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,906
精华内容 762
关键字:

以太坊令牌