在本文中，我们将使用Python部署智能合约。这篇文章可能是您走向智能合约和区块链开发的桥梁！

介绍

我希望可以在任何开发场景都尽量用Python。在区块链开发中，常用的是以太坊虚拟机智能合约语言Solidity，它具有许多不错的功能，并且仍然可以使用 Python 进行部署。刚开始使用Solidity时，我使用了Remix（https://remix.ethereum.org/），这是一个强大的Web IDE，可让您进行智能合约可视化。Remix很棒，我现在仍然使用它，但是在单个IDE之外可以实现很多其他功能。后来我开始学习Truffle（https://www.trufflesuite.com/）和HardHat（https://hardhat.org/guides/mainnet-forking.html），它们是用于部署智能合约的Node.js框架。

这些是到目前为止我所见过的主要框架，这些框架都不错，但是我更喜欢Python。所以当我发现Brownie 和web3.py：一个用于部署智能合约的Python框架和一个用于区块链开发的开源协议之后非常兴奋。我们将在本文中同时介绍Brownie和Web3.py。

为什么选择Python？

有这么多数据科学家、学者和金融科技机构使用Python是有原因的。它用途广泛，具有轻松的开发体验，并且与各种第三方库紧密结合在一起。顶级 defi 项目开始意识到这一点，诸如yearn.finance之类的项目使用python来部署其所有生产代码。Yearn.finance由一群非常有才华的金融科技工程师经营，他们转向了区块链，带着他们熟悉和喜爱的Python工具。

Brownie是什么？

Brownie是由Ben Hauser创建的Python智能合约开源框架，又名“iamdefinitelyahuman”（中文意思“非绝对人类”），是一件艺术品。这就是yearn.finance团队用来部署和维护智能合约的工具。您可以使用简单的命令启动项目，然后立即开始使用代码。

用Python部署您的第一个智能合约

1. 安装 Brownie 和 bake

Brownie具有“baking”功能，可让您使用一些基础代码启动存储库，因为大多数项目都需要很多相同的部分，类似于create-eth-app。要开始使用，和其他所有Python软件包的安装方式一样。

pip install eth-brownie

我们还需要安装ganache-cli一个用于部署本地区块链的软件包。为此，您需要安装npm和nodejs。

npm install -g ganache-cli

准备开始！我们将使用chainlink-mix入门，因为许多顶级defi项目都使用Chainlink来获取其资产数据。

brownie bake chainlink-mix
cd chainlink

通过ls命令将向我们展示项目的结构布局

Brownie项目布局

build : This is where the project keeps track of your deployed smart contracts and compiled contracts
contracts : The source code of your contracts, typically written in solidity or vyper
interfaces : A layout of interfaces you’ll need to work with deployed contracts. Every interaction with a contract needs an ABI and an address. Interfaces are great ways to get a contract’s ABI
scripts : Scripts we create to automate processes of working with our contracts
tests : Tests
brownie-config.yaml : This is where we have all the information for brownie to understand how to work with our smart contract. What blockchain do we want to deploy to? Are there any special parameters we want to set? All these are set in the config file.

requirements.txt，README.md，LICENSE和.gitignore可以忽略，您将在后面了解它们的用途。

2.设置环境变量

如果您熟悉区块链开发，就会知道本地区块链，测试网区块链和主网区块链都是不同的东西。我们将部署到测试网，以便我们可以与真实的实时区块链网络进行交互。您需要一个WEB3_INFURA_PROJECT_ID，可以通过创建Infura帐户来检索该WEB3_INFURA_PROJECT_ID。这就是我们用来连接到测试网络的东西。我们还将获得一个metamask或其他web3以太坊钱包，并用一些ETH进行注资。对于这个demo，我们要使用Kovan测试网络。

您可以跳过有关LINK资金的部分，我们只需要testnet ETH。我们也不会使用Ropsten，而是使用Kovan。如果您已经有了钱包，请从https://gitter.im/kovan-testnet/faucet获取一些Kovan Ether。

安装，配置和Metamask

一旦有了Metamask钱包，就可以将私钥导出到PRIVATE_KEY环境变量。在此处(https://www.twilio.com/blog/2017/01/how-to-set-environment-variables.html)阅读有关设置环境变量的信息。如果这仍然使您感到困惑，并且这只是一个测试钱包，请随意将代码中的PRIVATE_KEY替换为您的私钥和WEB3_INFURA_PROJECT_ID。

3.部署您的智能合约

在我们的脚本文件夹中，我们有一个名为deploy_price_consumer_v3.py的脚本，该脚本将部署我们的智能合约，该合约读取以太坊的美元价格。如果您想更轻松地了解该合约的功能以及如何部署它，请随时查看有关部署价格订阅合同的Chainlink教程(https://docs.chain.link/docs/beginners-tutorial/)。brownie run是我们可以用来运行脚本的命令。如果仅运行brownie，则可以看到所有命令的列表。

brownie run scripts/price_feed_scripts/deploy_price_consumer_v3.py --network kovan

--network kovan允许我们设置要使用的网络。我们正在使用kovan testnet进行此演示。您将需要Kovan ETH来做到这一点！您将获得很多输出内容，但最终会得到类似以下结果：

Running 'scripts/price_feed_scripts/deploy_price_consumer_v3.py::main'...
Transaction sent: 0x23d1dfa3937e0cfbab58f8d5ecabe2bfffc28bbe2349527dabe9289e747bac56
Gas price: 20.0 gwei   Gas limit: 145600   Nonce: 1339
PriceFeed.constructor confirmed - Block: 22721813   Gas used: 132364 (90.91%)
PriceFeed deployed at: 0x6B2305935DbC77662811ff817cF3Aa54fc585816

如果此方法正常运行，我们可以转到kovan etherscan并找到我们部署的合约。上面的链接显示了此示例中部署的合约。

4.读取您的智能合约

现在我们已经部署了智能合约，我们可以从刚刚部署的合约中读取以太坊的价格。我们将运行另一个脚本：

brownie run scripts/price_feed_scripts/read_price_feed.py --network kovan

得到类似以下的输出：

Brownie v1.12.2 - Python development framework for Ethereum
ChainlinkProject is the active project.
Running 'scripts/price_feed_scripts/read_price_feed.py::main'...
Reading data from 0x6B2305935DbC77662811ff817cF3Aa54fc585816
62322000000
Where 62322000000 is the current price of ETH in USD! Solidity doesn’t understand decimals, and we know that this example has 8 decimals, so the price is $623.22 .

您刚刚使用Python和Brownie部署了您的第一个智能合约！

使用web3.py

Brownie使用名为web3.py的工具让您的开发更轻松，但是如果机智点，则我们始终可以直接在没有框架的情况下使用合约。Web3.py是一个原始程序包，我们可以使用它来更直接地处理合同。为此，我们只需要上面的Kovan infura项目ID。请记住，要与任何智能合约进行交互，您需要做两件事：

• 智能合约ABI

• 智能合约地址

Brownie 会在后台处理很多此类工作，但我们也可以手动进行。这是通过web3.py从链上合同中读取的内容。首先，我们需要安装web3.py。

然后，我们可以在文件中运行以下内容。

web3 = Web3(Web3.HTTPProvider('https://kovan.infura.io/v3/<infura_project_id>')) 
abi = '[{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"description","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint80","name":"_roundId","type":"uint80"}],"name":"getRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]' 
addr = '0x9326BFA02ADD2366b30bacB125260Af641031331' 
contract = web3.eth.contract(address=addr, abi=abi) 
latestData = contract.functions.latestRoundData().call() print(latestData)

运行上述操作后将在我们的控制台中打印以美元为单位的ETH的最新价格。请查看Chainlink文档以确定是否有问题。

结论

您可以从他们的文档中了解有关Web3.py和Brown的更多信息。这两个项目都是开源的，任何人都可以做出贡献！

https://github.com/eth-brownie/brownie

https://github.com/ethereum/web3.py

传统的金融科技世界充满了使用户能够制作复杂算法交易模型和系统的工具。而去中心化金融 (DeFi) 也同样为用户和开发人员提供了相同的工具，围绕底层金融协议和工具具有更高的透明度和灵活性，从而催生了 DeFi 量化交易和应用开发。DeFi 开发人员和 DeFi quants 甚至可以利用这些工具的衍生品，并将它们组合成新的服务，以建立在传统金融科技世界中没有的创新金融头寸。DeFi 开发人员的基本工具之一是能够以非托管方式借出和借入加密货币资产。阅读本文前请先查看：\

用 Python 开发 DeFi 去中心化借贷应用（上）

用 Python 开发 DeFi 去中心化借贷应用（中）

获取可借资产价值

现在，当我们借款时，我们会被告知我们拥有的以 ETH 表示的资产数量。然而，也许我们想借用一个不同的代币，比如 DAI。如果我们要以 ETH 为抵押借入 DAI，我们首先要得到 ETH -> DAI 的兑换率。

Chainlink 是 DeFi 和智能合约生态系统中获取数据和执行外部计算的标准，也是 Aave 用来获取费率的标准！他们有一个价格 Oracle 部分，描述了如何通过他们的智能合约 API 获取 Chainlink 数据。如果你学会了一般地使用 Chainlink 数据，你可以跨协议使用它，即使他们没有使用 Chainlink，或者没有价格预言机机制！

Chainlink 通过去中心化的预言机网络获取数据，其中多个节点将跨多个 API 和服务的数据聚合到一个去中心化的来源，该来源经过验证并记录在链上供我们使用。我们可以在 data.chain.link 页面或文档上看到当前可用数据提要的列表。如您所知，数据是大多数量化系统、算法交易者和整个 DeFi 生态系统的支柱，因此您要始终确保自己是从去中心化系统中提取的，这样您就可以获得最准确、最可靠和最安全的数据。

此外，如果您不想要某些数据，您可以从任何 API 调用您的智能合约，获得可证明的随机数以及许多其他不同的服务。这些使得智能合约数据安全、可靠和去中心化。

但是让我们回到 Python！

我们有一个名为 get_asset_price 的函数，它从 dai_eth_price_feed 中读取数据，如下所示：

def get_asset_price():
   # For mainnet we can just do:
   # return Contract(f"{pair}.data.eth").latestAnswer() / 1e8
   dai_eth_price_feed = interface.AggregatorV3Interface(
       config["networks"][network.show_active()]["dai_eth_price_feed"]
   )
   latest_price = Web3.fromWei(dai_eth_price_feed.latestRoundData()[1], "ether")
   print(f"The DAI/ETH price is {latest_price}")
   return float(latest_price)

我们从接口中提取的 Chainlink 合约 AggregatorV3Interface 已存储在我们的配置文件中。在该合约中，我们调用 latestRoundData 函数。

你会注意到我们也不需要为这个做一个交易，这也是一个视图函数！

你会看到通过brownie获得 Chainlink 数据价格的另一种方式是：

from brownie import Contract
print(Contract(f"{pair}.data.eth").latestAnswer() / 1e8)

这是使用 ENS 来获取价格对的地址。ENS 是一种获取智能合约地址并使其可读的方法。例如，您可以执行以下操作：

print(Contract(f"eth-usd.data.eth").latestAnswer() / 1e8)

以美元为单位获取以太坊的最新价格。请注意，ENS 仅适用于主网网络，因此您在运行 brownie 时必须使用 --network mainnet 或 --network mainnet-fork。

将价值转换为借用

现在我们有了抵押品和我们想要借入的资产之间的转换率，我们可以设置一个变量来确定我们想要借入多少。

amount_erc20_to_borrow = (1 / erc20_eth_price) * (borrowable_eth * 0.95)

我们得到 ETH/DAI 价格的倒数，并将其乘以我们可以借入的金额（以 ETH 为单位）。为了安全起见，我们还将其乘以 0.95。然后，我们调用借用函数！

borrow_erc20(lending_pool, amount_erc20_to_borrow, account)

def borrow_erc20(lending_pool, amount, account, erc20_address=None):
   erc20_address = (
       erc20_address
       if erc20_address
       else config["networks"][network.show_active()]["aave_dai_token"]
   )
   # 1 is stable interest rate
   # 0 is the referral code
   transaction = lending_pool.borrow(
       erc20_address,
       Web3.toWei(amount, "ether"),
       1,
       0,
       account.address,
       {"from": account},
   )
   transaction.wait(1)
   print(f"Congratulations! We have just borrowed {amount}")

借用函数需要几个参数：

•资产的地址（在我们的例子中是 DAI 代币）•我们要借的金额，单位为 wei•interestRateMode，（0, 1, 2: 1 是稳定的，2 是可变的……现在不用担心 0）•推荐码（忽略）•onBehalfOf 值，即谁将承担债务

让我们看一下 Etherscan 上这笔交易的样本，以了解刚刚发生的事情。

按顺序，代币转移的方向是：

•Aave 协议正在铸造一些 aDAI•我们的钱包正在铸造一些 Aave Stable Debt Bearing DAI•我们的钱包获得了一些 DAI

重要说明：Aave 有时会更改其测试网token。通过检查已部署的合约地址，确保您拥有正确的 testnet DAI 地址。并检查官方 json 列表。

这一次，我们得到了一种不同类型的计息代币，一种债务代币。这是我们必须偿还的金额，并且与 aToken 一样，它的价值也会增长。如果你欠更多的债务（用这个债务代币表示），有人可以清算你并拿走你所有的抵押品！所以要警惕你有多少债务。

通过添加新的代币地址，我们可以再次在我们的 MetaNask 中看到借入的资产。我们还可以通过添加债务token地址来查看我们的债务。

这才是真正有趣的地方。现在最简单的卖空方法之一就是出售我们的资产。如果资产价格下跌，我们将不得不偿还比借入的更少的钱。

然而，我越来越担心我会被清算。让我们偿还我们的债务。

偿还我们的债务

我们想弄清楚我们欠了多少，然后偿还！我们可以用这些函数做到这一点：

borrowable_eth, total_debt_eth = get_borrowable_data(lending_pool, account)
amount_erc20_to_repay = (1 / erc20_eth_price) * (total_debt_eth * 0.95)
repay_all(amount_erc20_to_repay, lending_pool, account)

def repay_all(amount, lending_pool, account):
   approve_erc20(
       Web3.toWei(amount, "ether"),
       lending_pool,
       config["networks"][network.show_active()]["aave_dai_token"],
       account,
   )
   tx = lending_pool.repay(
       config["networks"][network.show_active()]["aave_dai_token"],
       Web3.toWei(amount, "ether"),
       1,
       account.address,
       {"from": account},
   )
   tx.wait(1)
   print("Repaid!")

总结

我们已经完成了与 Aave 合作的所有步骤。

•抵押•拿出贷款•偿还贷款

您接下来还可以做一些事情，比如：

•使用 Synthetix 或 Bancor 等协议交易资产•申请闪贷•了解如何质押和参与治理

您还可以学习如何成为智能合约开发人员，在 Solidity 中构建去中心化协议，并发现智能合约的广泛功能。你的旅程才刚刚开始！

传统的金融科技世界充满了使用户能够制作复杂算法交易模型和系统的工具。而去中心化金融 (DeFi) 也同样为用户和开发人员提供了相同的工具，围绕底层金融协议和工具具有更高的透明度和灵活性，从而催生了 DeFi 量化交易和应用开发。DeFi 开发人员和 DeFi quants 甚至可以利用这些工具的衍生品，并将它们组合成新的服务，以建立在传统金融科技世界中没有的创新金融头寸。DeFi 开发人员的基本工具之一是能够以非托管方式借出和借入加密货币资产。阅读本文前请先查看：

《用 Python 开发 DeFi 去中心化借贷应用（上）》

存入抵押品

接下来，我们运行 aave_borrow.py 脚本，它做了 4 件事：

•将抵押品存入 Aave 贷款池•获得了我们的抵押品和另一种资产之间的对话率•使用该抵押品借入不同的资产（贷款）•还清了贷款

我们看一下main函数的开头：

def main():
   account = get_account()
   erc20_address = config["networks"][network.show_active()]["weth_token"]
   if network.show_active() in ["mainnet-fork"]:
       get_weth(account=account)
   lending_pool = get_lending_pool()

我们首先从配置文件中获取我们的地址（如果我们在测试网上，它会再次从我们的配置中提取）。如果您在本地链上进行测试，我们只使用它生成的第一个帐户。这在 get_account 函数中定义。然后，我们也从配置文件中获取 WETH 令牌的地址，如果我们在本地链上，我们调用之前调用的相同 get_weth 函数。这是为了确保如果我们使用本地链，我们的钱包中有 WETH。

最后，我们得到了lending_pool的地址。 lending_pool是管理借贷功能的链上智能合约，因此得名。您可以在 Aave 文档中查看功能，或者您可以直接在链上查看合约。

我们在这个合约中看到了许多有用的功能：

•借贷•抵押•获取用户帐户数据•偿还

这些是我们将要使用的函数。请记住，链上智能合约与传统软件工程中的对象或类相同，每个都有与之相关的功能。如果您要print(type(lending_pool))，我们会得到这种类型：

<class 'brownie.network.contract.Contract'>

这意味着借贷池是一个合约，就像 WETH 一样！我们的 get_lending_pool() 函数实际上做了一些额外的步骤来获取贷款池合约。让我们看看这个函数：

def get_lending_pool():
   lending_pool_addresses_provider = interface.ILendingPoolAddressesProvider(
       config["networks"][network.show_active(
       )]["lending_poll_addresses_provider"]
   )
   lending_pool_address = lending_pool_addresses_provider.getLendingPool()
   lending_pool = interface.ILendingPool(lending_pool_address)
   return lending_pool

我们需要两个东西才能与智能合约进行交互：

•ABI/接口•地址

我们有位于interfaces文件夹中的借贷池的接口。你会注意到一个流行的接口约定是让它们以字母“I”开头。我们在这个例子中有一个mix，表示它不必以“I”开头。

为了让我们获得借贷池的地址，我们实际上必须通过 LendingPoolAddressesProvider 的地址。这是一个链上合约，其中包含 Aave 借贷池的所有地址。有时，出借池地址发生变化，但出借池提供者地址永远不会改变，因此我们始终可以使用该合约的地址来获取出借池地址。你会看到我们在lenting_pool_addresses_provider 变量上调用了 getLendingPool 函数。

让我们回到主函数。在我们得到了贷款池合约的地址后，我们要存入抵押品。这是我们需要做的第一步，因为只有放置了抵押品，我们才能获得贷款。我们也可以假设只存入抵押品！存入抵押品将使我们获得：

1、收益

该协议向将抵押品存入平台的用户支付报酬。

2、取出贷款

我们只有在有足够的抵押品的情况下才能贷款/借入。Aave 有一个名为 Liquidationcall 的函数，如果您没有足够的抵押品，任何人都可以调用该函数并获得奖励。抵押品的价值必须保持大于贷款的价值，这就是为什么这被称为超额抵押贷款。

3、流动性挖矿

也称为“收益耕作”，流动性挖矿是一种 DeFi 机制，它使用户能够以治理或其他类型代币的形式获得奖励，以向协议提供流动性。但是，为了让我们存入一些代币，我们必须批准智能合约才能将代币从我们的钱包中取出。我们将把我们的 WETH 作为抵押品。

approve_erc20(amount, lending_pool.address, erc20_address, account)

让我们看看我们的approve_erc20函数。

def approve_erc20(amount, lending_pool_address, erc20_address, account):
   print("Approving ERC20...")
   erc20 = interface.IERC20(erc20_address)
   tx_hash = erc20.approve(lending_pool_address, amount, {"from": account})
   tx_hash.wait(1)
   print("Approved!")
   return True

•amount：允许协议使用多少 ERC20，以 wei 为单位。 wei 是区块链世界中最小的计量单位。1 ETH == 1000000000000000000wei•lending_pool_address：借贷池地址。•erc20_address：ERC20 代币的地址。•account：我们想要交易的账户。

在使用 ERC20 代币时，如果我们希望从我们的钱包中“调用”另一个合约，我们必须首先批准该合约。我们调用 ERC20 合约（我们的 WETH）上的批准函数，然后我们“等待”该交易继续进行。

tx_hash.wait(1)

现在我们已经批准了合同，我们可以将我们的抵押品存入我们的主函数中的 Lotion_pool 合同中。

print("Depositing...")
   lending_pool.deposit(erc20_address, amount, account.address, 0, {"from": account})
   print("Deposited!")

我们可以在这里看到，我们在合约上调用了deposit函数，我们给了它：

•erc20_address：要存入的代币（在我们的例子中是 WETH）•amount：要存入的 wei 金额。•account.address：我们想为谁贷款，在这种情况下是我们自己。•0：这是推荐代码（已折旧，始终使用 0）

我们可以从 Aave 文档中了解更多关于智能合约中的存款功能。

如果你正确地完成了这部分，你会得到一个交易哈希，它会告诉你发生了什么。让我们看一个关于 Etherscan 上 Kovan 测试网的例子。

让我们深入了解发生了什么。如果我们查看 Tokens Transferred 部分，我们可以看到 1 笔存款交易发生了 3 笔交易。按顺序，这些是：

•一些 aToken 被铸造出来供我们存入 (aWETH)•我们发送了 1 个 WETH 到 lending_pool 合约（这是我们的存款）•我们收到了一些 aToken

所以中间代币转移是有道理的——我们正在向借贷池发送一些 WETH。但是其他token是什么？

aToken 是一种计息代币，在存款时铸造并在赎回时销毁。所以当你取回你的存款时，你烧掉你的 aToken 以获得等量的基础资产。 aTokens 最酷的部分是它们的价值每时每刻都在上涨！余额增加是因为人们使用 Aave 协议并借用您的资产，因此您因此获得报酬！

您可以查看某人的余额并每隔几秒钟刷新一次，以实时查看余额的增加情况。

每当我们想要赎回或提取我们的 WETH 时，无论我们拥有多少 aWETH，我们都会提取，而这些 aWETH 将被烧毁。

与 WETH token相同，您现在可以在您的 MetaMask 钱包中看到 aWETH。只需进入您的 MetaMask，并执行我们上面所做的添加的token部分，Kovan WETH 地址为 0x87b1f4cf9bd63f7bbd3ee1ad04e8f52540349347。

抵押/贷款

现在我们已经存入了一些抵押品，我们可以贷款了。现在我们为什么要贷款？

•无摩擦卖空•无需平仓即可获得流动性

您可以借入资产以保持对标的抵押品的敞口，同时还可以用另一种资产进行交易或支付。只要确保将您的健康系数保持在 1 以上。

您的健康因素是您贷款的抵押品数量。假设我存入了 1 ETH，借了 0.5 ETH。如果清算阈值为 1，那么我的健康系数将为 2。

清算门槛是贷款被定义为抵押不足的百分比。例如，清算门槛为 80% 意味着如果价值超过抵押品的 80%，则贷款抵押不足，可以清算。

但是假设我有 2 ETH 借入和 1 ETH 作为抵押品，1 作为清算门槛。我的健康系数是 0.5，我会被要求清算。这是清算人代表借款人偿还部分或全部未偿还借入金额的情况，同时获得折扣金额的抵押品作为回报（也称为清算“奖金”）。清算人可以决定他们是否想要获得等值的金额 抵押aToken，或者直接标的资产，当清算成功完成后，增加仓位的健康系数，使健康系数在1以上。通过这种方式，来保持贷款健康！

以我们的抵押品借款，我们首先要衡量我们作为抵押品的抵押品数据。我们可以调用贷款池上的 getUserAccountData 函数来找出这一点。

我们将它封装到一个名为 get_borrowable_data 的函数中

borrowable_eth, total_debt_eth = get_borrowable_data(lending_pool, account)

def get_borrowable_data(lending_pool, account):
   (
       total_collateral_eth,
       total_debt_eth,
       available_borrow_eth,
       current_liquidation_threshold,
       tlv,
       health_factor,
   ) = lending_pool.getUserAccountData(account.address)
   available_borrow_eth = Web3.fromWei(available_borrow_eth, "ether")
   total_collateral_eth = Web3.fromWei(total_collateral_eth, "ether")
   total_debt_eth = Web3.fromWei(total_debt_eth, "ether")
   print(f"You have {total_collateral_eth} worth of ETH deposited.")
   print(f"You have {total_debt_eth} worth of ETH borrowed.")
   print(f"You can borrow {available_borrow_eth} worth of ETH.")
   return (float(available_borrow_eth), float(total_debt_eth))

getUserAccountData 返回：

•totalCollateralETH•totalDebtETH•availableBorrowsETH•currentLiquidationThreshold•Ltv•healthFactor

您可以在 Aave 文档中阅读这些函数。我们只关注 available_borrow_eth 和 total_debt_eth，这样我们就会知道：

•我们可以借多少钱•我们目前有多少债务

为什么我还没有进行交易？

您可能已经注意到，这是对智能合约进行函数调用，而我们上面刚刚说过，为了调用函数，我们必须进行交易，那么我们给出了什么呢？其实有两种类型的智能合约功能，您无需进行交易即可调用。

•视图函数•纯函数

这些函数不会修改区块链的状态，因此我们可以调用它们，因为我们只是在读取智能合约的状态。请记住，如果您修改区块链的状态，它只会花费 gas。

回到贷款。每项资产都有不同的贷款借入比率，它告诉您的清算门槛，以便您借入资产。

一旦我们得出了可借贷款量，我们就可以借了！

borrowable_eth, total_debt_eth = get_borrowable_data(lending_pool, account)
print(f"LETS BORROW IT ALL")
erc20_eth_price = get_asset_price()
amount_erc20_to_borrow = (1 / erc20_eth_price) * (borrowable_eth * 0.95)
print(f"We are going to borrow {amount_erc20_to_borrow} DAI")
borrow_erc20(lending_pool, amount_erc20_to_borrow, account)

在本教程中，我们将介绍如何使用 Python 开发 DeFi 项目。去中心化金融 (DeFi) 是区块链和智能合约世界最重要的进步之一，通常被称为“新金融科技”。

读取您的智能合约

现在我们已经部署了一个智能合约，我们可以从刚刚部署的合约中读取 ETH 的价格。我们将使用我们拥有的另一个脚本：

brownie run scripts/price_feed_scripts/read_price_feed.py --network kovan

我们将得到如下输出：

Brownie v1.12.2- Python development framework forEthereum
ChainlinkProjectis the active project.
Running'scripts/price_feed_scripts/read_price_feed.py::main'...
Reading data from0x5A….
122322000000

其中 122322000000 是 ETH 的当前美元价格！Solidity 不理解小数，我们知道 Chainlink Price Feeds 有 8 位小数，所以价格是 $1,223.22 。

您刚刚使用 Python 和 Brownie 部署了您的第一个智能合约！

测试你的智能合约

这也是如何测试智能合约的一个很好的例子。我们甚至使用模拟对象在本地进行测试！

只需运行：

brownie test

您的测试将在本地 Ganache 实例上运行！

您还可以使用以下内容在测试网上进行测试：

brownie test --network kovan

这些测试具有一些功能，可以知道您是否在测试网络上工作。如果您在本地工作，它会部署 虚拟或“模拟”的预言机代码，以便我们可以对其进行测试。

总结

现在您知道如何使用 Python 部署智能合约，您可以开始在此框架之上构建以做更多有趣的事情。Python 拥有强大的软件包，如 Numpy、Scikit、Pandas 和 TensorFlow，可用于执行定量工作、机器学习等。能够最终将这些技术结合在一起是金融科技新时代成功的秘诀：去中心化金融。

Chainlink 是一个灵活的框架，用于将外部金融数据和系统引入链上，并与 Numpy 和 Pandas 等以数据为中心的软件包无缝集成。如果您是开发人员并希望快速将您的应用程序连接到 Chainlink，请访问开发人员文档。

https://docs.chain.link/?_ga=2.263617100.1196435661.1623840137-1423897284.1623840137

在本教程中，我们将介绍如何使用 Python 开发 DeFi 项目。去中心化金融 (DeFi) 是区块链和智能合约世界最重要的进步之一，通常被称为“新金融科技”。目前，智能合约开发由 JavaScript 主导，部分原因可能是 JavaScript 是地球上最常用的语言，并且与 Node.js 配合构建全栈应用程序更容易。然而，量化分析师、股票交易员和对冲基金的金融科技世界并非如此。大多数金融科技公司出于各种原因使用 Python：

• 更高效的开发体验

• 强大的人工智能和机器学习

• 捆绑的金融科技包

• 综合分析工具

• 生产环境中的可靠性

如此多的数据科学家、学者和金融科技机构使用 Python 是有原因的。DeFi 领域的一些项目，如yearn.finance，分享了这种观点，并使用 Python 和 Solidity 构建了他们的整个 DeFi 平台。正是由于像 web3.py 和 Brownie 这样的库和框架，我们才能看到这些项目变得生动起来。Brownie 是一个类似于 Truffle 的框架（它们都非常“sweet”），它维护您的部署、脚本、测试，并允许您制作端到端的后台。

Web3.py和Brownie还提供了“mix”，你可以在其中使用一些样板代码预打开项目。这就是我们今天将使用的Chainlink Brownie mix。

现在我们为什么要使用 Chainlink + Python？正如 Python 是金融科技事实上的编程语言一样，Chainlink 是将链下数据提供给 DeFi 智能合约的事实上的预言机解决方案，目前为顶级 DeFi 协议提供了超过 7B 美元的价值。这两种技术的结合为去中心化金融科技领域提供了一个安全而强大的框架。

以下是 Chainlink 在 2020 年启用的一些功能的快速浏览。

要开始使用 Brownie 和 Python 构建 DeFi 应用程序，您首先需要安装 Python。此时不建议 Python 低于 3.4 版本，因此如果您的版本低于 3.4，请升级。您可以通过运行以下命令查看您的 Python 版本并验证它是否已正确安装：

python --version

或者，如果使用 python3：

python3 --version

您还需要安装 Ganache。Ganache 是一个用 Python 编写的一键式区块链应用，可让您轻松启动本地区块链。尽管您必须使用 npm 和 node.js 下载它，但这将是您必须与之交互的唯一 JavaScript 片段。

首先，您需要安装 node.js 和 npm。Node.js 随 npm 一起安装。下载后，您可以通过运行以下命令来检查它是否正确完成：

npm -v

然后，您可以通过命令行安装 Ganache。

npm install -g ganache-cli

安装完成后，我们将像安装所有 Python 存储库一样使用 pip 安装 eth-brownie！

pip install eth-brownie

或者如果使用 pip3：

pip3 install eth-brownie

如果您在终端中运行 brownie，您就会知道您做对了，您会得到类似于以下内容的输出：

Brownie v1.13.0- Python development framework forEthereum
Usage:  brownie <command> [<args>...] [options <args>]
Commands:
  init               Initialize a new brownie project
  bake               Initializefrom a brownie-mix template
  pm                 Installand manage external packages
  compile            Compile the contract source files
  console            Load the console
  test               Run test cases in the tests/ folder
  run                Run a script in the scripts/ folder
  accounts           Managelocal accounts
  networks           Manage network settings
  gui                Load the GUI to view opcodes and test coverage
  analyze            Find security vulnerabilities using the MythX API
Options:
--help -h          Displaythis message
--version          Show version andexit
Type'brownie <command> --help'for specific options and more information about
each command.

此外，您还需要一个 MetaMask 或其他以太坊钱包。请使用 Kovan测试网获得ETH。请确保您的 ETH 钱包中有一些 testnet LINK 和 Kovan ETH。您可以在 LINK faucet 和 ETH Kovan faucet 中找到一些。

启动 Chainlink 项目

要开始使用Brownie,，我们可以使用所谓的Brownie mix 来为我们提供样板代码。在这个例子中，我们将部署一个简单的 Chainlink Price Feed 作为了解 Brownie 框架的一种方式。让我们bake chainlink-mix。

brownie bake chainlink-mix
cd chainlink

这将使我们进入一个新项目，其中已经为我们构建了一些默认代码。如果我们运行 ls 我们可以看到文件的布局是什么样的：

• build ：这是项目跟踪您部署的智能合约和编译的合约的地方

• contracts：合同的源代码，通常用 Solidity 或 Vyper 编写

• interfaces ：您需要使用已部署合同的接口布局。与合约的每次交互都需要一个 ABI 和一个地址。接口是获取合约 ABI 的好方法

• scripts：我们创建的脚本来自动化处理我们的合同的过程 测试

• tests：测试

• brownie-config.yaml ：这是我们为 Brownie 了解如何使用我们的智能合约提供所有信息的地方。我们要部署到哪个区块链？有没有我们想要设置的特殊参数？所有这些都在配置文件中设置。

现在可以忽略 requirements.txt 、 README.md 、 LICENSE 和 .gitignore。当您练习时，您会发现它们的用途。

设置环境变量

尽管我们只是安装了 Ganache 来进行本地测试，但我们也希望能够连接到 ETH 主网和测试网，以便我们可以将它们部署在真实的测试网上。为此，我们需要设置 WEB3_INFURA_PROJECT_ID。您可以从 Infura 站点免费获得一个 Infura ID。您也可以使用其他 web3 提供程序或您自己的节点，但您必须为此做更多的配置。

在您的 brownie-config.yaml 文件中，您可以使用主机密钥设置网络，并定义您不想使用 MetaMask 时想要连接的 URL。

现在您有了 web3 ID，我们需要将我们的私钥作为环境变量，以便我们可以将我们的帐户与我们的钱包一起使用。如果您使用 MetaMask，请查找导出密钥。使用 MetaMask，您可能需要在私钥的开头添加 0x。建议在测试和导出密钥时使用与主帐户不同的帐户，以防万一。

现在，要使它们成为环境变量，只需在终端中运行以下命令：

export PRIVATE_KEY=0x96789…..
export WEB3_INFURA_PROJECT_ID=’dog cat mouse….’

如果你运行 printenv 并在那里看到你的环境变量，你就会知道你做对了。

部署您的智能合约

现在我们已经设置好了一切，我们甚至可以继续将智能合约部署到 Kovan 测试网！

在我们的脚本文件夹中，我们有一个名为 deploy_price_consumer_v3.py的脚本。这将部署我们的智能合约，以美元读取以太坊的价格。

只需使用 brownie run 即可使用部署脚本：

brownie run scripts/price_feed_scripts/deploy_price_consumer_v3.py --network kovan

你会看到这样的东西：

Running'scripts/price_feed_scripts/deploy_price_consumer_v3.py::main'...
Transaction sent: 0x23d1dfa3937e0cfbab58f8d5ecabe2bfffc28bbe2349527dabe9289e747bac56
Gas price: 20.0 gwei   Gas limit: 145600Nonce: 1339
PriceFeed.constructor confirmed - Block: 22721813Gas used: 132364(90.91%)
PriceFeed deployed at: 0x6B2305935DbC77662811ff817cF3Aa54fc585816

如果这工作正常，我们可以去 Kovan Etherscan 并找到我们部署的合约。上面的链接显示了此示例中部署的合约。

在本文中，我们将学习如何使用 Brownie、Python 和 Chainlink 来制作非同质化的 NFT 作品，并在 OpenSea NFT 市场上展示和销售我们的成果。

动态和高级 NFT

动态 NFT 是可以随时间变化的 NFT，或者具有我们可以用来相互交互的链上功能。这些 NFT 可以无限定制，让我们可以制作整个游戏、元宇宙（metaverse）或某种互动艺术。下面我们进入高级部分。

高级快速入门

确保您的metamask中有足够的测试网 ETH 和 LINK，然后运行以下命令：

brownie run scripts/advanced_collectible/deploy_advanced.py --network rinkeby
brownie run scripts/advanced_collectible/create_collectible.py --network rinkeby

我们的收藏品是从 Chainlink VRF 返回的随机犬种。Chainlink VRF 是一种获得可证明随机数的方法，因此我们的 NFT 真正稀缺。然后我们想要创建它的元数据。

brownie run scripts/advanced_collectible/create_metadata.py --network rinkeby

然后我们可以选择将此数据上传到 IPFS，以便我们可以拥有一个 tokenURI。稍后我会告诉你如何做到这一点。现在，我们将仅使用以下示例 tokenURI：

https://ipfs.io/ipfs/Qmd9MCGtdVz2miNumBHDbvj8bigSgTwnr4SbyH6DNnpWdt?filename=1-PUG.json

如果您将 IPFS Companion 下载到您的浏览器中，您可以使用该 URL 来查看 URI 返回的内容。它看起来像这样：

{
    "name": "PUG",
    "description": "An adorable PUG pup!",
    "image": "https://ipfs.io/ipfs/QmSsYRx3LpDAb1GZQm7zZ1AuHZjfbPkD6J7s9r41xu1mf8?filename=pug.png",
    "attributes": [
        {
            "trait_type": "cuteness",
            "value": 100
        }
    ]
}

然后我们可以运行我们的 set_tokenuri.py 脚本：

brownie run scripts/advanced_collectible/set_tokenuri.py --network rinkeby

我们会得到这样的输出：

Running 'scripts/advanced_collectible/set_tokenuri.py::main'...
Working on rinkeby
Transaction sent: 0x8a83a446c306d6255952880c0ca35fa420248a84ba7484c3798d8bbad421f88e
  Gas price: 1.0 gwei   Gas limit: 44601   Nonce: 354
  AdvancedCollectible.setTokenURI confirmed - Block: 8331653   Gas used: 40547 (90.91%)
Awesome! You can view your NFT at https://testnets.opensea.io/assets/0x679c5f9adC630663a6e63Fa27153B215fe021b34/0
Please give up to 20 minutes, and hit the "refresh metadata" button

我们可以点击给出的链接，看看它在 Opensea 上的样子！您可能需要点击刷新元数据按钮并等待几分钟。

随机品种

然我们看一下刚刚做了什么。这是我们的 AdvancedCollectible.sol：

pragma solidity 0.6.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
contract AdvancedCollectible is ERC721, VRFConsumerBase {
    uint256 public tokenCounter;
    enum Breed{PUG, SHIBA_INU, BRENARD}
    // add other things
    mapping(bytes32 => address) public requestIdToSender;
    mapping(bytes32 => string) public requestIdToTokenURI;
    mapping(uint256 => Breed) public tokenIdToBreed;
    mapping(bytes32 => uint256) public requestIdToTokenId;
    event requestedCollectible(bytes32 indexed requestId); 
    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public randomResult;
    constructor(address _VRFCoordinator, address _LinkToken, bytes32 _keyhash)
    public 
    VRFConsumerBase(_VRFCoordinator, _LinkToken)
    ERC721("Dogie", "DOG")
    {
        tokenCounter = 0;
        keyHash = _keyhash;
        fee = 0.1 * 10 ** 18;
    }
    function createCollectible(string memory tokenURI, uint256 userProvidedSeed) 
        public returns (bytes32){
            bytes32 requestId = requestRandomness(keyHash, fee, userProvidedSeed);
            requestIdToSender[requestId] = msg.sender;
            requestIdToTokenURI[requestId] = tokenURI;
            emit requestedCollectible(requestId);
    }
    function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
        address dogOwner = requestIdToSender[requestId];
        string memory tokenURI = requestIdToTokenURI[requestId];
        uint256 newItemId = tokenCounter;
        _safeMint(dogOwner, newItemId);
        _setTokenURI(newItemId, tokenURI);
        Breed breed = Breed(randomNumber % 3); 
        tokenIdToBreed[newItemId] = breed;
        requestIdToTokenId[requestId] = newItemId;
        tokenCounter = tokenCounter + 1;
    }
    function setTokenURI(uint256 tokenId, string memory _tokenURI) public {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _setTokenURI(tokenId, _tokenURI);
    }
}

我们使用 Chainlink VRF 从 PUG、SHIBA_INU、BRENARD 列表中创建一个随机品种。当我们这次调用 createCollectible 时，我们实际上向链下的 Chainlink VRF 节点发起了一个请求，并返回一个随机数，以使用这 3 个品种之一创建 NFT。

在你的 NFT 中使用真正的随机性是创造真正稀缺性的好方法，使用 Chainlink oracle 随机数意味着你的数字可以证明是随机的，并且不会受到矿工的影响。

您可以在文档中了解有关 Chainlink VRF 的更多信息。

https://docs.chain.link/docs/chainlink-vrf/

Chainlink 节点通过调用 fulfillRandomness 函数进行响应，并根据随机数创建收藏品。然后我们仍然需要调用 _setTokenURI 来为我们的 NFT 提供它需要的外观。

我们没有在这里给出我们的 NFT 属性，但属性是让我们的 NFT 进行交互的好方法。您可以在此 龙与地下城示例中看到具有属性的 NFT 的一个很好的示例。

https://github.com/PatrickAlphaC/dungeons-and-dragons-nft

来自 IPFS 的元数据

我们使用 IPFS 来存储两个文件：

• NFT 的形象（哈巴狗形象）

• tokenURI 文件（JSON 文件，其中还包含图像的链接）

我们使用 IPFS 是因为它是一个免费的去中心化平台。我们可以通过下载 IPFS 桌面并点击导入按钮将我们的 tokenURI 和图像添加到 IPFS。

然后，我们可以通过点击要共享的文件旁边的 3 个点、点击共享链接并复制给定的链接来共享 URI。然后我们可以将此链接添加到我们的 set_tokenuri.py 文件中以更改我们想要使用的 tokenURI。

持久性

但是，如果 tokenURI 仅在我们的节点上，这意味着当我们的节点关闭时，没有其他人可以查看它。所以我们希望其他人 pin我们的 NFT。我们可以使用 Pinata 之类的 pin服务来帮助我们的数据保持活动状态，即使我们的 IPFS 节点已关闭。

我想未来会有越来越多的元数据存储在 IPFS 和去中心化存储平台上。集中式服务器可能会宕机，这意味着这些 NFT 上的艺术将永远丢失。请务必检查您使用的 NFT 的 tokenURI 所在的位置！

我也希望更多的人会使用像 Filecoin 这样的 dStorage 平台，因为使用 pin服务也没有像它应该的那样去中心化。

现在，您已经具备了制作漂亮有趣、可定制、交互式 NFT 的技能，并让它们在市场上呈现。

NFT 是一种有趣、强大的方式，可以补偿艺术家们所做的辛勤工作。

在本文中，我们将学习如何使用 Brownie、Python 和 Chainlink 来制作非同质化的 NFT 作品，并在 OpenSea NFT 市场上展示和销售我们的成果。

什么是 NFT？

NFT英文全称为Non-Fungible Token，翻译成中文就是：非同质化代币，具有不可分割、不可替代、独一无二等特点。NFT由于其非同质化、不可拆分的特性，使得它可以和现实世界中的一些商品绑定。换言之，其实就是发行在区块链上的数字资产，这个资产可以是游戏道具、数字艺术品、门票等，并且具有唯一性和不可复制性。由于NFT具备天然的收藏属性和便于交易，加密艺术家们可以利用NFT创造出独一无二的数字艺术品。

ERC20 与 ERC721

NFT 是类似于 ERC20 的区块链token标准，如 AAVE、SNX 和 LINK（技术上为 ERC677）。ERC20 是“可替代”的代币，意思是“可替换”或“可互换”。

例如，无论您使用什么美元纸币，您的美元纸币都将值 1 美元。美元钞票上的序列号可能不同，但钞票是可以互换的，无论如何它们都值 1 美元。

另一方面，NFT 是“不可替代的”，它们遵循自己的代币标准 ERC721。例如，蒙娜丽莎是“不可替代的”。即使有人可以复制它，但永远只有一个蒙娜丽莎。如果蒙娜丽莎是在区块链上创建的，它将是 NFT。

NFT 有什么用？

NFT 通过将合约永久地部署在链上，让创作者、艺术家、游戏设计师等创造价值。

你将永远知道谁创造了 NFT，谁拥有 NFT，它来自哪里等等，这种独特性让他们比传统艺术更有价值。在传统艺术中，理解什么是“假货”可能很棘手，而链上的历史很容易追溯。

由于智能合约和 NFT 是 100% 可编程的，NFT 还可以添加内置的版税和任何其他功能。补偿艺术家一直是一个问题，因为通常艺术家的作品在没有任何归属的情况下四处传播。

越来越多的艺术家和工程师开始利用这一巨大的附加值，因为这最终成为艺术家获得工作报酬的好方法。不仅如此，NFT 还是一种展示您的创造力并成为数字世界收藏家的有趣方式。

NFT 的价值

NFT 已经走过了漫长的道路，我们不断看到 NFT 的销售额创下纪录，例如下面这幅名为“每天：前 5,000 天”的画作售价为 6930 万美元。

NFT也是在数字世界中创造艺术和了解智能合约创建的一种有趣、动态和引人入胜的方式。所以现在将教你制作 NFT 所需的一切知识。

如何制作 NFT

现在，制作 NFT 的最简单方法就是前往 Opensea、Rarible 或 Mintible 等平台，并按照他们的分步指南在他们的平台上进行部署即可。

你可以 100% 走这条路，但是你可能会被平台绑定。你无法实现无限的定制，或者真正利用 NFT 的任何优势。

如果你想用代码来实现，学习一些扎实的知识，并有能力以无限的创造力创造出一些东西，那么请继续阅读！

如何进行无限定制的 NFT

首先介绍NFT Brownie Mix。这是一个包含大量样板代码的工作仓库。

https://github.com/PatrickAlphaC/nft-mix

先决条件

我们需要安装一些东西才能开始：

• Python

• Nodejs 和 npm

• Metamask

如果您不熟悉 Metamask，您可以按照下面教程进行设置。

https://docs.chain.link/docs/install-metamask/

Rinkeby Testnet ETH 和 LINK

我们还将部署在 Rinkeby 以太坊测试链上！

测试链是测试我们的智能合约在现实世界中表现的好方法。我们需要 Rinkeby ETH 和 Rinkeby LINK，我们可以从 Chainlink 文档中最新水龙头的链接中免费获得它们。

我们还需要将 rinkeby LINK 的token添加到metamask中，我们可以按照 LINK 文档进行操作。

https://docs.chain.link/docs/acquire-link/

注意一定要使用 Rinkeby 而不是 Ropsten。在使用像以太坊这样的智能合约平台时，我们需要支付一点 ETH，而从链下获取数据时，我们需要支付一点 LINK。这就是我们需要获取测试链上的LINK 和 ETH 的原因。

下面这件作品就是我们要部署到 OpenSea 的 NFT。

https://testnets.opensea.io/assets/0x8acb7ca932892eb83e4411b59309d44dddbc4cdf/0

快速上手

git clone https://github.com/PatrickAlphaC/nft-mix
cd nft-mix

现在我们需要安装 ganache-cli 和 eth-brownie。

pip install eth-brownie
npm install -g ganache-cli

现在我们可以设置我们的环境变量。如果您不熟悉环境变量，只需将它们添加到 .env 文件中，然后运行：

source .env

.env的示例应该在你刚刚克隆的 repo 中，并注释掉了环境变量。请确保取消注释以使用它们！

您需要一个 WEB3_INFURA_PROJECT_ID和一个 PRIVATE_KEY 。WEB3_INFURA_PROJECT_ID 可以在注册免费 Infura 帐户时找到。这将为我们提供一种将交易发送到区块链的方法。

我们还需要一个私钥，您可以从您的 Metamask 中获取。点击 3 个小点，然后单击帐户详细信息和导出私钥。如果您投入现金进去，请不要与任何人分享此密钥！

export PRIVATE_KEY=YOUR_KEY_HERE
export WEB3_INFURA_PROJECT_ID=YOUR_PROJECT_ID_HERE

现在我们可以部署我们的 NFT 合约并使用以下两个命令创建我们的第一个收藏品。

brownie run scripts/simple_collectible/deploy_simple.py --network rinkeby
brownie run scripts/simple_collectible/create_collectible.py --network rinkeby

第一个脚本将我们的 NFT 合约部署到 Rinkeby 区块链，第二个脚本创建了我们的第一个收藏品。

您刚刚部署了第一个智能合约！

它根本没有什么作用，但别担心——我将在本教程的高级部分向您展示如何在 OpenSea 上渲染它。首先，让我们看看 ERC721 代币标准。

ERC721 代币标准

我们来看看我们刚刚部署的合约，在 SimpleCollectible.sol 文件中。

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
import"@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract SimpleCollectibleis ERC721 {
    uint256 public tokenCounter;
    constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
}
function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
return newItemId;
}
}

我们将 OpenZeplin 包用于 ERC721 token。导入的这个包允许我们使用典型 ERC721 token的所有功能。这定义了我们的代币将具有的所有功能，例如 transfer——将代币转移给新用户， safeMint——创建新代币，等等。

您可以通过查看 OpenZepplin ERC721 代币合约找到赋予我们合约的所有功能。我们的合约在下面一行继承了这些功能：

https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol

contract SimpleCollectibleis ERC721 {

这就是 Solidity 继承的方式。当我们部署一个合约时，构造函数会被自动调用，它需要一些参数。

constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
}

我们还使用了 ERC721 的构造函数，在我们的构造函数中，我们只需要给它一个名称和一个符号。在我们的例子中，它是“Dogie”和“DOG”。这意味着我们创建的每个 NFT 都将是 Dogie/DOG 类型。

这就像每张口袋妖怪卡仍然是口袋妖怪，或者交易卡上的每个棒球运动员仍然是棒球运动员。每个棒球运动员都是独一无二的，但他们仍然都是棒球运动员。我们只是使用 DOG 类型。

我们在顶部有 tokenCounter 来计算我们创建了多少这种类型的 NFT。每个新token都会根据当前的 tokenCounter 获得一个 tokenId。

实际上可以使用 createCollectible 函数创建 NFT。这就是我们在 create_collectible.py 脚本中所写的。

function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
return newItemId;
}

_safeMint函数创建新的 NFT，并将其分配给调用 createdCollectible的人，也就是 msg.sender，并使用从 tokenCounter 派生的 newItemId。这就是我们如何通过检查 tokenId的所有者来跟踪谁拥有什么。

您会注意到我们还调用了 _setTokenURI。让我们来看一下。

什么是 NFT 元数据和 TokenURI？

当创建智能合约和创建 NFT 时，人们很快意识到将大量数据部署到区块链是非常昂贵的。小至 1 KB 的图像的存储成本很容易超过 100 万美元。

这显然是 NFT 的一个问题，因为拥有创意艺术意味着您必须将这些信息存储在某个地方。他们还想要一种轻量级的方式来存储有关 NFT 的属性——这就是 tokenURI 和元数据发挥作用的地方。

TokenURI

NFT 上的 tokenURI 是token“外观”的唯一标识符。URI 可以是通过 HTTPS 的 API 调用、IPFS 哈希值或任何其他独特的东西。

它们遵循显示元数据的标准，如下所示：

{
"name": "name",
"description": "description",
"image": "https://ipfs.io/ipfs/QmTgqnhFBMkfT9s8PHKcdXBn1f5bG3Q5hmBaR4U6hoTvb1?filename=Chainlink_Elf.png",
"attributes": [
{
"trait_type": "trait",
"value": 100
}
]
}

这些显示了 NFT 的外观及其属性。图像部分指向 NFT 外观的另一个 URI。这使得 Opensea、Rarible 和 Mintable 等 NFT 平台可以轻松地在其平台上呈现 NFT，因为它们都在寻找这种元数据。

链下元数据与链上元数据

现在你可能会想“等等......如果元数据不在链上，这是否意味着我的 NFT 可能会在某个时候消失”？你是对的。

您认为链下元数据意味着您不能使用该元数据让您的智能合约相互交互也是正确的。

这就是为什么我们要专注于链上元数据，以便我们可以对 NFT 进行编程以相互交互。

但是，我们仍然需要链下元数据的图像部分，因为我们没有一种很好的方法来在链上存储大图像。但是别担心，我们仍然可以通过使用 IPFS 在去中心化网络上免费做到这一点。

这是来自 IPFS 的 imageURI示例，它显示了在龙与地下城教程中创建的 ChainlinkElf。

https://blog.chain.link/build-deploy-and-sell-your-own-dynamic-nft/

我们没有为简单的 NFT 设置 tokenURI，因为我们只想展示一个基本示例。

下一篇将讲解 NFT 进阶知识，这样就可以看到我们用链上元数据实现的一些惊人功能，在 opeansea 上渲染 NFT，并让我们的狗狗振作起来！

Uniswap是一个基于以太坊的交易所协议，允许任何人交换ERC20代币。普遍上讲，交易代币要求买卖双方创造委托订单，而Uniswap则是自动创建一个交易市场。Uniswap旨在帮助解决去中心化交易所的流动性问题，是一种去中心化的交易所。

在过去的几个月里，我在 Uniswap 上新上市的币上观察到了一个非常有趣的规律，尤其是那些被炒作的币种。在新币上市后的前 10-15 分钟内，价格上涨非常高，不过在接下来的几个小时内大幅下跌，然后在接下来的 24 小时内上涨超过 50%。不要以为你可以在价格低的时候买进，然后10分钟后高价卖出。因为以太坊网络拥堵的原因，这段时间的gas费用非常高（数百美元）。

Superfarm 是之前比较受欢迎的一个新项目，在 Telegram 上拥有超过 86,000 名成员，在 Twitter 上拥有超过 88,000 名关注者。所以我决定来测试一下这个规律，或者说我决定进行推测。在最初的几分钟里，价格飙升至 2 美元左右，然后跌至 1 美元左右，因此我决定投资 0.98 eth（按当前价格计算约 1.5K 美元）。

第二天，如果价格要上涨，我必须观察价格才能退出我在 Superfarm 代币上的头寸。每分钟检查价格真的是在浪费时间，所以我决定制作一个脚本来监控价格，如果价格达到某个目标，它会通知我。

为了查看 Uniswap 的价格，我使用了 uniswap-python 库。

!pip install uniswap-python

如果你想知道我为什么使用它，pip 前面的感叹号是因为我已经在 Jupyter Notebook 中进行了编码，并且我已经从 Notebook 单元安装了所有必要的 python 库。

eth = "0x0000000000000000000000000000000000000000"
dai = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
sup = "0xe53EC727dbDEB9E2d5456c3be40cFF031AB40A55"

address = "0x0000000000000000000000000000000000000000"  #  if you're not making transactions
private_key = None  # if you're not going to make transactions

provider = <the url of your provider> # if you use Infura 
 will be 
 like 'https://mainnet.infura.io/v3/########'
uniswap_wrapper = Uniswap(address, private_key, version=2, provider=provider)  # use Uniswap v2

第一个变量包含我们想要在 Uniswap 上获得加密货币的以太坊地址校验和。

要获取加密货币的以太坊地址校验和，您可以使用 Coingecko 首先获取合约地址：

然后你就可以使用下面网站轻松从合约地址中获取以太坊地址校验和。

https://ethsum.netlify.app/

如果您不太熟悉什么是以太坊地址校验和，您可以将其视为一个标识符，基于这个加密货币标识符 Uniswap 将能够为您提供价格。

provider（web3 provider）是一个运行 geth 或 parity 节点的网站，它与以太坊网络交互。要获得provider，您可以使用 Infura。如果您使用 Infura，必须注册然后创建一个新项目，在设置选项卡上您可以看到提供商 URL：

要获得以 eth 表示的 Superfarm 币价格：

sup_price = uniswap_wrapper.get_token_eth_input_price(sup, 10 ** 18)

print(sup_price / 10**18)
# 0.000901625376604887

10 ** 18代表Superfarm 币的数量，它必须是一个整数值，如果我们选择小数量值将是0（由于近似），所以我们需要一个大数量。我们将获得 10 ** 18个 Superfarm 币的 eth 价格。

如果我们想以美元计算 1 个 Superfarm 币的价格，我们可以使用 Dai 稳定币（1 Dai ~= 1 美元）。我们可以请求相同数量的 Superfarm 和 Dai 币，然后分割它们。

def get_sup_price_in_dollars():
    sup_price = uniswap_wrapper.get_token_eth_input_price(sup, 10 ** 18)
    dai_price = uniswap_wrapper.get_token_eth_input_price(dai, 10 ** 18)
    return round(sup_price / dai_price, 4)

print(get_sup_price_in_dollars())
# 1.357 --> the price in dollars for 1 Superfarm coin

为了在我的桌面上推送通知，我使用了plyer库：

!pip install plyer

这是监控 Superfarm 价格和自前一个值以来的变化的函数：

from plyer import notification

def notify(price: int, new_price: int):
    notification.notify(
    title = 'Superfarm price whatcher',
    message = f"Total value of SUPER = {new_price}, change: {round(new_price - price, 3)}",
    timeout = 10,
    app_icon = '/home/kederrac/Pictures/uniswap.ICO',
    )

如您所见，我还添加了一个应用程序图标，为了能够使用应用程序图标，我还必须将 .png 图片转换为 .ico 格式，安装 dbus-python 库（如果您使用的是 Windows，则不需要）。

!pip install  dbus-python

现在让我们把它们放在一起：

import time

price = get_sup_price_in_dollars()
notify(price, price)

while True:
    new_price = get_sup_price_in_dollars()
    
    if abs(price - new_price) > 0.05:
        notify(price, new_price)
        
    price = new_price
    time.sleep(10)

在这里，我每 10 秒调用一次 get_sup_price_in_dollars() 函数来检查价格是否发生变化，如果变化大于 0.05 美元，将推送通知，您可以更改变化的最小值以获得通知，或者您 可以设置要通知的最低价格目标。

结果如下：

（在 ubuntu 20.04 上）

（在 windows 10 上）

这对于实时价格通知非常有帮助，这种方法的另一优点是速度，与必须使用 Coingecko 相比，您将获得数分钟的时间，如果您使用 Uniswap 网络界面，时间将更快。

在这里你可以看到我一开始所说的规律：

什么是 DApp

“DApp”代表去中心化应用程序。与传统应用程序一样，去中心化应用程序也有前端（客户端）和后端（服务器端）。DApp 的用户界面可以用任何语言编写（就像传统应用程序一样），并且可以调用其后端。那么，Dapps 与传统应用程序有何不同？DApp 的后端代码运行在分散的对等网络（即区块链）上。您可能听说过 BitTorrent、Tor、Popcorn Time——它们是在点对点网络上运行但不在区块链上运行的 DApp。区块链 DApp 有自己的后端代码，称为智能合约，可以部署到区块链（最常见的是以太坊）。智能合约定义了整个 DApp 的逻辑。它是使用区块链作为后端的命脉。那么Python 开发人员可以在哪里利用它？重点来了——web3。Web3 是一组库，允许您与本地或远程以太坊区块链进行交互。简单地说，web3 是与您的后端（区块链）通信的桥梁。幸运的是，以太坊开发人员已经制作了一个 python 库 web3.py 用于与以太坊进行交互。它的 API 源自 web3 的 JavaScript 版本。因此，除了 web3.js，我们也可以通过 web3.py 库与区块链进行交互。

Dapps 开发包括三个简单的步骤：

• 在区块链网络上部署智能合约

• 从部署的智能合约中读取数据

• 将交易发送到部署的智能合约

我们将在带有 web3.py 库的 python 环境中一步一步地进行这三个操作要与区块链交互，我们必须连接到任何完全同步的节点。在本教程中，我们指向一个 Infura 节点。确保你有一个以太坊钱包（使用 Metamask chrome 扩展或 myetherwallet 创建以太坊钱包并安全地存储你的私钥）并在其中添加一些测试 Ether 以进行操作。

安装

• Python 2.7 +

• Node.js

• Truffle

npm install -g truffle

• Pip

npm i pip

• web3.py

• Infura 项目 API

前往 Infura 网站并注册。创建一个新项目并复制 Ropsten Infura RPC URL。我们将把我们的智能合约部署到 Ropsten 测试网络。

智能合约

每个程序员都用他们最喜欢的编程语言执行了一个“hello world”程序，以了解运行该语言的基础知识。这是我们使用 Solidity 语言编写的简单的“hello world”版本的智能合约，我们可以在区块链上添加问候语并检索它。Solidity 是编写智能合约最常用的语言，它编译为可以在节点上运行的以太坊虚拟机上执行的字节码。

pragma solidity ^0.5.7;
contract greeter{
string greeting;
function greet(string memory _greeting)public{
        greeting=_greeting;
}
function getGreeting() public view returns(string memory) {
return greeting;
}
}

您可以通过传递字符串值使用 greet() 方法添加问候语，并使用 getGreting() 方法检索问候语。

1. 在区块链网络上部署智能合约

a) 创建项目：

mkdir pythonDapp
cd pythonDapp
truffle init

成功初始化项目后，转到您的文件夹并在 /contracts目录中创建 greeter.sol 文件。在网络上部署合约之前，我们必须编译它并构建工件。

b) 智能合约的编译：

因此，对于编译，我们将使用 Truffle solc 编译器。在您的主目录中，运行以下命令：

truffle compile
(or)
truffle.cmd compile #(for windows only)

上面的命令将在 /contracts 目录中编译你的合约，并在 /build 目录中创建二进制工件文件 greeter.json。

c) 部署合约：

打开您的 Python IDLE 编辑器，并在主目录 deploy.py 中使用以下代码创建一个新文件，然后在您的目录中运行 py deploy.py。

import json
from web3 importWeb3, HTTPProvider
from web3.contract importConciseContract
# web3.py instance
w3 = Web3(HTTPProvider("https://ropsten.infura.io/v3/<API key>"))
print(w3.isConnected())
key="<Private Key here with 0x prefix>"
acct = w3.eth.account.privateKeyToAccount(key)
# compile your smart contract with truffle first
truffleFile = json.load(open('./build/contracts/greeter.json'))
abi = truffleFile['abi']
bytecode = truffleFile['bytecode']
contract= w3.eth.contract(bytecode=bytecode, abi=abi)
#building transaction
construct_txn = contract.constructor().buildTransaction({
'from': acct.address,
'nonce': w3.eth.getTransactionCount(acct.address),
'gas': 1728712,
'gasPrice': w3.toWei('21', 'gwei')})
signed = acct.signTransaction(construct_txn)
tx_hash=w3.eth.sendRawTransaction(signed.rawTransaction)
print(tx_hash.hex())
tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash)
print("Contract Deployed At:", tx_receipt['contractAddress'])

这是我所做的：

• 导入的 web3 库和所有其他必需的模块

• 通过指向 Ropsten Infura 节点启动 web3 提供程序

• 添加了用于签署交易的帐户地址和私钥。不要忘记在代码中添加您的凭据。

• 通过指向 Truffle 编译的工件文件greeter.json的abi和字节码启动合约实例

• 添加了带有随机数、gas、gasPrice 等参数的construct_txn。此处，gas 是指交易应在以太坊中使用和支付的最大计算资源量。gasPrice 是指在交易中使用该数量的 gas 时的最小 Ether 数量。to 指的是您发送交易的地址。仅当您将 Ether 发送到帐户或智能合约时才需要 to 参数。

• 使用我们的私钥签署交易并在网络上广播。

• 在控制台中记录交易哈希和部署的合约地址。根据以太坊的说法，事务处理时间 <20 秒。所以你必须等待 20 秒才能获得部署的合约地址。您的后端现在已成功部署在以太坊区块链上。现在您可以使用此地址与您的智能合约进行交互。复制此合约地址。

2. 向部署的合约发送交易

在我们的合约中，有一个方法greet()。我们可以单独使用这种方法在我们的合同中添加问候语。让我们看看我们如何使用 web3.py 来做到这一点。打开您的 Python IDLE 编辑器并使用以下代码创建一个新文件 sign.py。然后在您的目录中运行 py sign.py。

import json
from web3 importWeb3, HTTPProvider
from web3.contract importConciseContract
# compile your smart contract with truffle first
truffleFile = json.load(open('./build/contracts/greeter.json'))
abi = truffleFile['abi']
bytecode = truffleFile['bytecode']
# web3.py instance
w3 = Web3(HTTPProvider("https://ropsten.infura.io/v3/<API key>")) #modify
print(w3.isConnected())
contract_address = Web3.toChecksumAddress("<Deployed Contract Address here>") #modify
key="<Private key with 0x prefix here>"#modify
acct = w3.eth.account.privateKeyToAccount(key)
account_address= acct.address
# Instantiate and deploy contract
contract = w3.eth.contract(abi=abi, bytecode=bytecode)
# Contract instance
contract_instance = w3.eth.contract(abi=abi, address=contract_address)
# Contract instance in concise mode
#contract_instance = w3.eth.contract(abi=abi, address=contract_address, ContractFactoryClass=ConciseContract)
tx = contract_instance.functions.greet("Hello all  my goody people").buildTransaction({'nonce': w3.eth.getTransactionCount(account_address)})
#Get tx receipt to get contract address
signed_tx = w3.eth.account.signTransaction(tx, key)
#tx_receipt = w3.eth.getTransactionReceipt(tx_hash)
hash= w3.eth.sendRawTransaction(signed_tx.rawTransaction)
print(hash.hex())

这是我所做的：

• 导入的 web3 库和所有其他必需的模块

• 通过指向 Ropsten Infura 节点启动 web3 提供程序

• 添加了用于签署交易的帐户地址和私钥

• 通过指向 Truffle 编译的工件文件greeter.json的abi和字节码启动合约实例

• 创建 tx 对象以添加问候语“hello all my goody people”并建立交易

• 使用我们的私钥签署交易并在网络上广播。

• 在控制台中记录交易哈希。您可以使用您的交易哈希在 etherscan 上检查交易状态。一旦交易被矿工验证，我们的问候语将被添加到区块链上。您可以使用 getGreeting() 函数检索问候语，如下所述。

3. 从部署的智能合约中读取数据

在我们的合约中，有一个方法 getGreeting() 可以检索我们在区块链中添加的问候语。我们将使用 web3.py 调用此方法 打开您的 Python IDLE 编辑器并使用以下代码创建一个新文件 read.py。运行 py read.py 读取问候语。

import json
from web3 importWeb3, HTTPProvider
from web3.contract importConciseContract
# compile your smart contract with truffle first
truffleFile = json.load(open('./build/contracts/greeter.json'))
abi = truffleFile['abi']
bytecode = truffleFile['bytecode']
# web3.py instance
w3 = Web3(HTTPProvider("https://ropsten.infura.io/<ApI Key here>"))
print(w3.isConnected())
contract_address = Web3.toChecksumAddress("<Deployed Contract Address here>")
# Instantiate and deploy contract
contract = w3.eth.contract(abi=abi, bytecode=bytecode)
# Contract instance
contract_instance = w3.eth.contract(abi=abi, address=contract_address)
# Contract instance in concise mode
#contract_instance = w3.eth.contract(abi=abi, address=contract_address, ContractFactoryClass=ConciseContract)
# Getters + Setters for web3.eth.contract object ConciseContract
#print(format(contract_instance.getGreeting()))
print('Contract value: {}'.format(contract_instance.functions.getGreeting().call()))

这是我所做的：

• 导入的 web3 库和所有其他必需的模块

• 通过指向 Ropsten Infura 节点启动 web3 提供程序

• 通过指向 abi 和 contract_Address 创建合约实例（来自上一步）

• 调用 getGreeting() 方法并在控制台打印结果

结论

您现在应该了解如何使用 web3.py 部署、交互和签署交易。让我们通过查看我使用 web3.py 创建的实时 DApp 并在此处使用 Flask 作为前端服务器来将所有部分组合在一起。它将帮助您更深入地了解使用 Python 进行 DApp 开发。

在市值排名前 10 的加密货币中，从纯粹的经济角度来看，你认为自 2017 年以来表现最好的加密货币是哪一种？\

不管你信不信，币安自己的 BNB 实际上远远超过了其他所有加密货币。我编写了一个脚本来帮助我了解几种加密货币的历史表现，当我决定只加入前 10 名加密货币并看看表现最好的货币是哪个。

在运行脚本之前，我很确定它可能将是 DOGE。所以我坐在这里，等待历史数据下载，以便我的脚本可以绘制一些加密图表。

脚本运行完毕，结果出来了，感谢中本聪，这不是 DOGE。哦，等等，这更有趣——它是 BNB。

自 2017 年以来，BNB 已上涨超过 20,000%。

程序能够为你下载历史数据，并分析任意数量的币种。如果您想对任意数量的加密货币的收益百分比进行快速比较分析，这很方便。您所需要的只是一些 Python 知识。

编写加密货币分析工具

该代码也可在 GitHub 上找到。

https://github.com/CyberPunkMetalHead/crypto-performance-tracker

首先创建一个文本文件并将其命名为coins.txt。在此文本文件中，放入一些您想要分析的币种名称。它们需要包含配对符号，并且每行必须是 1 个货币，不能有逗号：

创建一个 binancedata.py 文件。我们将使用此文件轮询 Binance API 以获取我们需要的金融数据。由于我们使用的是开放端口，因此不需要 API 密钥和密码。

让我们导入一些依赖项并定义一个空的 Binance 客户端：

# needed for the binance API and websockets
from binance.client import Client
import csv
import os
import time
from datetime import date, datetime

client = Client()

现在让我们编写一个函数来从我们的coins.txt文件中打开和读取货币：

def get_coins():
    with open('coins.txt', 'r') as f:
        coins = f.readlines()
        coins = [coin.strip('\n') for coin in coins]
    return coins

此文件中的最后一个函数将为我们获取历史数据并以 CSV 格式保存：

def get_historical_data(coin, since, kline_interval):
    """
    Args example:
    coin = 'BTCUSDT'
    since = '1 Jan 2021'
    kline_interval = Client.KLINE_INTERVAL_1MINUTE
    """
    if os.path.isfile(f'data/{coin}_{since}.csv'):
        print('Datafile already exists, loading file...')

    else:
        print(f'Fetching historical data for {coin}, this may take a few minutes...')

        start_time = time.perf_counter()
        data = client.get_historical_klines(coin, kline_interval, since)
        data = [item[0:5] for item in data]

        # field names
        fields = ['timstamp', 'high', 'low', 'open', 'close']

        # save the data
        with open(f'data/{coin}_{since}.csv', 'w', newline='') as f:

            # using csv.writer method from CSV package
            write = csv.writer(f)

            write.writerow(fields)
            write.writerows(data)

        end_time = time.perf_counter()

        # calculate how long it took to produce the file
        time_elapsed = round(end_time - start_time)

        print(f'Historical data for {coin} saved as {coin}_{since}.csv. Time elapsed: {time_elapsed} seconds')
    return f'{coin}_{since}.csv'

此函数还将检查文件是否已经存在，如果存在它不会再次下载。该函数接受 3 个参数：coin、since 和 kline_interval。检查函数下方的注释，了解我们将传递给这些参数的正确格式。

保存文件，现在是创建我们的主要执行文件的时候了，我们将把这个文件的内容导入到其中。

继续创建一个 main.py 文件并安装以下依赖项：

from binancedata import *
import threading


import matplotlib.pyplot as plt
import matplotlib.cbook as cbook

import numpy as np
import pandas as pd

# needed for the binance API and websockets
from binance.client import Client
import csv
import os
import time
from datetime import datetime, date

让我们开始一些线程。该脚本是为了一次下载多个数据文件，所以为了避免等待一次下载每个历史数据文件，我们将使用线程并下载这些文件，如下所示：

threads = []
coins = get_coins()
for coin in coins:

    t = threading.Thread(target=get_historical_data, args=(coin, '1 Jan 2017', Client.KLINE_INTERVAL_1DAY) ) #'get_historical_data('ETHUSDT', '1 Jan 2021', Client.KLINE_INTERVAL_1MINUTE)
    t.start()
    threads.append(t)


[thread.join() for thread in threads]

现在我们需要一个函数来返回我们下载的所有数据文件的文件名：

def get_all_filenames():
    return [get_historical_data(coin, '1 Jan 2017', Client.KLINE_INTERVAL_1DAY) for coin in coins]

最后，我们将定义主要函数，我们将在其中绘制这些数据并运行脚本：

def main():
    historical_data = get_all_filenames()

    for file in historical_data:
        data = pd.read_csv(f'data/{file}')

        rolling_percentage = data['close']
        rolling_percentage = [(item - rolling_percentage[0]) / rolling_percentage[0]*100 for item in rolling_percentage ]

        timestamp = data['timstamp']
        timestamp = [datetime.fromtimestamp(item/1000) for item in timestamp]

        plt.legend()
        plt.plot(timestamp, rolling_percentage, label=file)
        plt.xlabel("Date")
        plt.ylabel("% gain")

    plt.show()

if __name__ == "__main__":
    main()

现在剩下要做的就是在脚本目录中创建一个空文件夹并将其命名为 data。大功告成，您现在可以分析您想要的所有代币的历史收益。

CCXT框架 是一个Python/Javascript/PHP的一个交易API框架，对接超过130多个交易所。可用于世界各地的加密货币交易所的连接和交易，以及转账支付处理，可用于存储数据，分析，可视化，指标开发，算法交易，是一个非常容易集成的开箱即用的统一API。

CCXT框架Github地址：

https://github.com/ccxt/ccxt

当前功能列表：

• 支持许多交易市场，甚至即将推出的

• 为所有交易提供完整的公共和私人API

• 所有货币，山寨币和标记，价格，订单，交易，代码等…

• 提供用于交叉交换或跨货币分析和套利的可选标准化数据

• 开箱即用的统一的一体化API，非常易于集成

• 适用于Node7.6+，Python2和3，PHP5.4+，Web浏览器

认证交易所

支持的加密货币交易所

ccxt库目前支持以下131个加密货币交易所和交易API，可以在github查看。上面的列表经常更新，新的加密市场，山寨币交换，错误修复，API端点定期引入和添加。有关详细信息，请参阅手册，如果你没有在上面的列表中找到加密货币交易市场和/或想要添加其他交易所，请通过GitHub或通过电子邮件在此处发布问题来发布或向我们发送链接。

该库受到MIT许可，这意味着任何开发人员都可以完全免费构建商业和开源软件，但使用它需要你自担风险且无需担保。

安装

安装ccxt库的最简单方法是使用内置包管理器：

• NPM中的ccxt（JavaScript/Node v7.6+）

• PyPI中的ccxt（Python 2和3.5.3+）

• Packagist/Composer中的ccxt（PHP 5.4+）

该库作为一体化模块实现提供，具有最小的依赖性和要求：

• js/在JavaScript中

• python/在Python中（从JS生成）

• PHP/ PHP（从JS生成）

也可以从ccxt GitHub存储库将其克隆到项目目录中：

git clone https://github.com/ccxt/ccxt.git

将此库安装到代码中的另一种方法是将单个文件手动复制到工作目录中，并使用适合你环境的语言扩展名。

安装

常用接口

# 初始化交易所
binance_exchange = ccxt.binance({
'timeout': 15000,
'enableRateLimit': True
})
# 获取单个交易对ticker数据
binance_exchange.fetchTicker(symbol)
# 获取多个交易对ticker数据
tickers_data = binance_exchange.fetchTickers(['BTC/USDT', 'ETH/USDT'])
# 交易委托账本数据获取
binance_exchange.fetch_order_book(symbol)
# K线数据数据获取
binance_exchange.fetch_ohlcv(symbol, timeframe='1d')

使用

CCXT里面的交易所都集成来自Exchange的基类，然后每个交易所实现了一些统一的api接口，另外也实现自己交易所特有的api方法。统一的api方法分为不需要权限就能访问的，比如loadmarkets(加载市场的交易对)、 fetchticker（获取ticker）等，需要权限访问的方法如fetchbalance(获取张账户资金)、createorder(生成订单)等。CCXT的方法名称有两种实现方式，一种是驼峰法, 另外一种是下划线命名法，在python中，推荐使用下划线方法来调用。

公共API包括

• 市场数据

• 交易对

• 交易手续费

• 订单薄/深度数据

• 交易历史

• 行情/Tickers

• 用以制图的 OHLC(V)/K线

• 其他公共接口

私有API包括

• 管理个人账户信息

• 查询账户余额

• 通过市价单和限价单进行交易

• 存入和提取法币和加密货币

• 查询个人订单

• 获取交易明细/历史

• 在账户之间转移资金

• 使用商业服务

此库为所有交换实现完整的公共和私有REST API。即将推出JavaScript，PHP，Python和其他语言的WebSocket和FIX实现。

ccxt库支持 camelcase表示法（在JavaScript中是首选）和下划线表示法（在Python和PHP中首选），因此所有方法都可以用任何语言的符号或编码方式调用。

// both of these notations work in JavaScript/Python/PHP
exchange.methodName ()  // camelcase pseudocode
exchange.method_name () // underscore pseudocode

Python

# coding=utf-8
import ccxt
hitbtc = ccxt.hitbtc({'verbose': True})
bitmex = ccxt.bitmex()
huobi  = ccxt.huobi()
exmo   = ccxt.exmo({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
})
kraken = ccxt.kraken({
'apiKey': 'YOUR_PUBLIC_API_KEY',
'secret': 'YOUR_SECRET_PRIVATE_KEY',
})
exchange_id = 'binance'
exchange_class = getattr(ccxt, exchange_id)
exchange = exchange_class({
'apiKey': 'YOUR_API_KEY',
'secret': 'YOUR_SECRET',
'timeout': 30000,
'enableRateLimit': True,
})
hitbtc_markets = hitbtc.load_markets()
print(hitbtc.id, hitbtc_markets)
print(bitmex.id, bitmex.load_markets())
print(huobi.id, huobi.load_markets())
print(hitbtc.fetch_order_book(hitbtc.symbols[0]))
print(bitmex.fetch_ticker('BTC/USD'))
print(huobi.fetch_trades('LTC/CNY'))
print(exmo.fetch_balance())
# sell one ฿ for market price and receive $ right now
print(exmo.id, exmo.create_market_sell_order('BTC/USD', 1))
# limit buy BTC/EUR, you pay €2500 and receive ฿1  when the order is closed
print(exmo.id, exmo.create_limit_buy_order('BTC/EUR', 1, 2500.00))
# pass/redefine custom exchange-specific order params: type, amount, price, flags, etc...
kraken.create_market_buy_order('BTC/USD', 1, {'trading_agreement': 'agree'})

本文使用 requests 库来调用 Binance REST API。如果你更喜欢 API 库，你可以尝试 python-binance。

Binance REST API

有 3 种类型的安全接口：

• NONE：可以自由访问

• USER_STREAM 和 MARKET_DATA：需要 APIKey

• TRADE 和 USER_DATA：需要 APIKey 和签名

获取币安 APIKey 和 SecretKey

BinanceDashboard -> Settings -> APIManagement

https://www.binance.com/en/usercenter/settings/api-management

创建带有标签的 APIKey（用于标识密钥用途和用途的名称）：生成 APIKey 和 SecretKey。

注意：请立即复制密钥，因为您无法在稍后阶段再次检索密钥，除非您创建另一个新密钥。

您可以设置 API 限制：只读、启用交易、启用提款。

您可以限制某些特定 IP 访问 API。

import time
import json
import hmac
import hashlib
import requests
from urllib.parse import urljoin, urlencode
API_KEY = 'UIGu...'
SECRET_KEY = 'VyX...'
BASE_URL = 'https://api.binance.com'
headers = {
'X-MBX-APIKEY': API_KEY
}

classBinanceException(Exception):
def __init__(self, status_code, data):
self.status_code = status_code
if data:
self.code = data['code']
self.msg = data['msg']
else:
self.code = None
self.msg = None
        message = f"{status_code} [{self.code}] {self.msg}"
# Python 2.x
# super(BinanceException, self).__init__(message)
super().__init__(message)

服务器时间

PATH =  '/api/v1/time'
params= None
timestamp = int(time.time() * 1000)
url = urljoin(BASE_URL, PATH)
r = requests.get(url, params=params)
if r.status_code == 200:
# print(json.dumps(r.json(), indent=2))
    data = r.json()
print(f"diff={timestamp - data['serverTime']}ms")
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

获取价格

PATH = '/api/v3/ticker/price'
params= {
'symbol': 'BTCUSDT'
}
url = urljoin(BASE_URL, PATH)
r = requests.get(url, headers=headers, params=params)
if r.status_code == 200:
print(json.dumps(r.json(), indent=2))
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

输出：

{
"symbol": "BTCUSDT",
"price": "10261.03000000"
}

获取订单簿

PATH = '/api/v1/depth'
params= {
'symbol': 'BTCUSDT',
'limit': 5
}
url = urljoin(BASE_URL, PATH)
r = requests.get(url, headers=headers, params=params)
if r.status_code == 200:
print(json.dumps(r.json(), indent=2))
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

输出：

{
"lastUpdateId": 784184836,
"bids": [["10229.67000000","0.01954500"],
["10229.58000000","6.90000000"],
["10229.56000000","0.33099600"],
["10228.54000000","0.02600900"],
["10227.71000000","0.50000000"]
],
"asks": [["10232.59000000","0.01703200"],
["10232.60000000","3.05388400"],
["10232.63000000","0.25000000"],
["10235.07000000","0.15200000"],
["10236.35000000","0.25000000"]
]
}

创建订单

PATH = '/api/v3/order'
timestamp = int(time.time() * 1000)
params= {
'symbol': 'ETHUSDT',
'side': 'SELL',
'type': 'LIMIT',
'timeInForce': 'GTC',
'quantity': 0.1,
'price': 500.0,
'recvWindow': 5000,
'timestamp': timestamp
}
query_string = urlencode(params)
params['signature'] = hmac.new(SECRET_KEY.encode('utf-8'), query_string.encode('utf-8'), hashlib.sha256).hexdigest()
url = urljoin(BASE_URL, PATH)
r = requests.post(url, headers=headers, params=params)
if r.status_code == 200:
    data = r.json()
print(json.dumps(data, indent=2))
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

{
"symbol": "ETHUSDT",
"orderId": 336683281,
"clientOrderId": "IVGyfNu88LhRnpZFa56JA4",
"transactTime": 1562252912748,
"price": "500.00000000",
"origQty": "0.10000000",
"executedQty": "0.00000000",
"cummulativeQuoteQty": "0.00000000",
"status": "NEW",
"timeInForce": "GTC",
"type": "LIMIT",
"side": "SELL",
"fills": [
{
"price": "500.00000000",
"qty": "0.050000000",
"commission": "1.00000000",
"commissionAsset": "USDT"
},
{
"price": "500.00000000",
"qty": "0.03000000",
"commission": "0.50000000",
"commissionAsset": "USDT"
},
]
}

获取订单

PATH = '/api/v3/order'
timestamp = int(time.time() * 1000)
params= {
'symbol': 'ETHUSDT',
'orderId': '336683281',
'recvWindow': 5000,
'timestamp': timestamp
}
query_string = urlencode(params)
params['signature'] = hmac.new(SECRET_KEY.encode('utf-8'), query_string.encode('utf-8'), hashlib.sha256).hexdigest()
url = urljoin(BASE_URL, PATH)
r = requests.get(url, headers=headers, params=params)
if r.status_code == 200:
    data = r.json()
print(json.dumps(data, indent=2))
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

{
"symbol": "ETHUSDT",
"orderId": 336683281,
"clientOrderId": "IVGyfNu88LhRnpZFa56JA4",
"price": "500.00000000",
"origQty": "0.10000000",
"executedQty": "0.00000000",
"cummulativeQuoteQty": "0.00000000",
"status": "NEW",
"timeInForce": "GTC",
"type": "LIMIT",
"side": "SELL",
"stopPrice": "0.00000000",
"icebergQty": "0.00000000",
"time": 1562252912748,
"updateTime": 1562252912748,
"isWorking": true
}

删除订单

PATH = '/api/v3/order'
timestamp = int(time.time() * 1000)
params= {
'symbol': 'ETHUSDT',
'orderId': '336683281',
'recvWindow': 5000,
'timestamp': timestamp
}
query_string = urlencode(params)
params['signature'] = hmac.new(SECRET_KEY.encode('utf-8'), query_string.encode('utf-8'), hashlib.sha256).hexdigest()
url = urljoin(BASE_URL, PATH)
r = requests.delete(url, headers=headers, params=params)
if r.status_code == 200:
    data = r.json()
print(json.dumps(data, indent=2))
else:
raiseBinanceException(status_code=r.status_code, data=r.json())

{
"symbol": "ETHUSDT",
"origClientOrderId": "IVGyfNu88LhRnpZFa56JA4",
"orderId": 336683281,
"clientOrderId": "2Fh1EdAmHU8ZUR0TwjrQAR",
"price": "500.00000000",
"origQty": "0.10000000",
"executedQty": "0.00000000",
"cummulativeQuoteQty": "0.00000000",
"status": "CANCELED",
"timeInForce": "GTC",
"type": "LIMIT",
"side": "SELL"
}

数据集创建

首先，让我们介绍一个新的“数据集”业务对象来对价格进行分组。

./models/dataset.py

from datetime import datetime

from api import utils
from models.model import AbstractModel
from models.exchange import Exchange
from models.currency import Currency

class Dataset(AbstractModel):
    resource_name = 'datasets'

    pair: str = ''
    exchange: str = ''
    period_start: str = ''
    period_end: str = ''
    currency: str = ''
    asset: str = ''

    relations = {'exchange': Exchange, 'currency': Currency, 'asset': Currency}

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.pair = self.get_pair()

    def get_pair(self):
        return utils.format_pair(self.currency, self.asset)

引入服务对象

我们需要构建一个服务来解析和加载Binance交易所或任何其他具有API和此类历史行情自动收录器端点的历史数据。

./services/importer.py

import sys
from datetime import datetime
from models.dataset import Dataset

class Importer:
    def __init__(self, exchange, period_start: datetime, period_end=None, interval=60, *args, **kwargs):
        self.exchange = exchange
        self.interval = interval
        self.period_start = period_start
        self.period_end = period_end
        self.start = datetime.now()
        self.dataset = Dataset().create(
            data={'exchange': '/api/exchanges/'+self.exchange.name.lower(), 'periodStart': self.period_start, 'periodEnd': self.period_end,
                  'candleSize': 60,
                  'currency': '/api/currencies/'+self.exchange.currency.lower(), 'asset': '/api/currencies/'+self.exchange.asset.lower()})

    def process(self):
        for price in self.exchange.historical_symbol_ticker_candle(self.period_start, self.period_end, self.interval):
            print(price.create({'dataset': '/api/datasets/'+self.dataset.uuid}))

        execution_time = datetime.now() - self.start
        print('Execution time: ' + str(execution_time.total_seconds()) + ' seconds')
        sys.exit()

这项服务职责非常简单明了，他的名字说明了一切，我们从交易所导入和存储历史行情自动收录器数据。

在这里，您可以将对象直接存储在诸如PostgreSQL之类的关系数据库中，也可以构建内部REST API并将其用作数据库的代理，以实现高性能。

回测

回测是编写您未来的机器人并根据历史行情自动收录器数据针对所有市场情况进行测试的最重要工具。

为此，我们将创建一个回测服务，他的职责是从您当前的本地数据中加载数据集，如果找不到，则直接从交易所加载（默认情况下为Binance）。然后针对历史数据集中的每个价格数据运行给定策略。

/services/backtest.py

import sys
from datetime import datetime

from exchanges.exchange import Exchange
from models.dataset import Dataset
from models.price import Price

class Backtest:
    def __init__(self, exchange: Exchange, period_start: datetime, period_end=None, interval=60):
        self.launchedAt = datetime.now()
        # Try to find dataset
        dataset = Dataset().query('get', {"exchange": '/api/exchanges/' + exchange.name.lower(),
                                          "currency": '/api/currencies/' + exchange.currency.lower(),
                                          "asset": '/api/currencies/' + exchange.asset.lower(),
                                          "period_start": period_start, "period_end": period_end, "candleSize": interval})

        if dataset and len(dataset) > 0:
            print(dataset[0])
            price = Price()
            for price in price.query('get', {"dataset": dataset[0]['uuid']}):
                newPrice = Price()
                newPrice.populate(price)
                exchange.strategy.set_price(newPrice)
                exchange.strategy.run()
        else:
            print("Dataset not found, external API call to " + exchange.name)
            for price in exchange.historical_symbol_ticker_candle(period_start, period_end, interval):
                exchange.strategy.set_price(price)
                exchange.strategy.run()

        execution_time = datetime.now() - self.launchedAt
        print('Execution time: ' + str(execution_time.total_seconds()) + ' seconds')
        sys.exit()

项目配置

我们将使用dotenv库来管理环境变量。这是项目的默认值：

./.env.local

AVAILABLE_EXCHANGES="coinbase,binance"
EXCHANGE="binance"

BINANCE_API_KEY="Your Binance API KEY"
BINANCE_API_SECRET="Your Binance API SECRET"

COINBASE_API_KEY="Your Coinbase API KEY""
COINBASE_API_SECRET="Your Coinbase API SECRET""

# Available modes
# "trade" to trade on candlesticks
# "live" to live trade throught WebSocket
# "backtest" to test a strategy for a given symbol pair and a period
# "import" to import dataset from exchanges for a given symbol pair and a period
MODE="trade"
STRATEGY="logger"
# Allow trading "test" mode or "real" trading
TRADING_MODE="test"
# Default candle size in seconds
CANDLE_INTERVAL=60
CURRENCY="BTC"
ASSET="EUR"
# Default period for backtesting: string in UTC format
PERIOD_START="2021-02-28T08:49"
PERIOD_END="2021-03-09T08:49"

DATABASE_URL="postgresql://postgres:password@127.0.0.1:15432/cryptobot"

主线程

然后将所有这些部分放到一个主线程上，主要是使用args以及环境变量的CLI命令。

这样，我们可以覆盖任何默认环境设置，并直接使用基于命令行的客户端直接调整所有输入参数。

例如，在使用诸如Docker之类的容器化工具时，它也确实非常有用，只需启动此主线程，它将与特定容器的环境变量一起运行。

我们将根据设置动态加载和导入我们创建的每个组件。

./main.py

#!/usr/bin/python3

import importlib
import signal
import sys
import threading
from decouple import config

from services.backtest import Backtest
from services.importer import Importer

exchange_name = config('EXCHANGE')
available_exchanges = config('AVAILABLE_EXCHANGES').split(',')
mode: str = config('MODE')
strategy: str = config('STRATEGY')
trading_mode: str = config('TRADING_MODE')
interval: int = int(config('CANDLE_INTERVAL'))
currency: str = config('CURRENCY')
asset: str = config('ASSET')

if trading_mode == 'real':
    print("*** Caution: Real trading mode activated ***")
else:
    print("Test mode")

# Parse symbol pair from first command argument
if len(sys.argv) > 1:
    currencies = sys.argv[1].split('_')
    if len(currencies) > 1:
        currency = currencies[0]
        asset = currencies[1]

# Load exchange
print("Connecting to {} exchange...".format(exchange_name[0].upper() + exchange_name[1:]))
exchangeModule = importlib.import_module('exchanges.' + exchange_name, package=None)
exchangeClass = getattr(exchangeModule, exchange_name[0].upper() + exchange_name[1:])
exchange = exchangeClass(config(exchange_name.upper() + '_API_KEY'), config(exchange_name.upper() + '_API_SECRET'))

# Load currencies
exchange.set_currency(currency)
exchange.set_asset(asset)

# Load strategy
strategyModule = importlib.import_module('strategies.' + strategy, package=None)
strategyClass = getattr(strategyModule, strategy[0].upper() + strategy[1:])
exchange.set_strategy(strategyClass(exchange, interval))

# mode
print("{} mode on {} symbol".format(mode, exchange.get_symbol()))
if mode == 'trade':
    exchange.strategy.start()

elif mode == 'live':
    exchange.start_symbol_ticker_socket(exchange.get_symbol())

elif mode == 'backtest':
    period_start = config('PERIOD_START')
    period_end = config('PERIOD_END')

    print(
        "Backtest period from {} to {} with {} seconds candlesticks.".format(
            period_start,
            period_end,
            interval
        )
    )
    Backtest(exchange, period_start, period_end, interval)

elif mode == 'import':
    period_start = config('PERIOD_START')
    period_end = config('PERIOD_END')

    print(
        "Import mode on {} symbol for period from {} to {} with {} seconds candlesticks.".format(
            exchange.get_symbol(),
            period_start,
            period_end,
            interval
        )
    )
    importer = Importer(exchange, period_start, period_end, interval)
    importer.process()

else:
    print('Not supported mode.')

def signal_handler(signal, frame):
    if (exchange.socket):
        print('Closing WebSocket connection...')
        exchange.close_socket()
        sys.exit(0)
    else:
        print('stopping strategy...')
        exchange.strategy.stop()
        sys.exit(0)

# Listen for keyboard interrupt event
signal.signal(signal.SIGINT, signal_handler)
forever = threading.Event()
forever.wait()
exchange.strategy.stop()
sys.exit(0)

用法

# Real time trading mode via WebSocket
MODE=live ./main.py BTC_EUR

# Trading mode with default 1 minute candle
MODE=trade ./main.py BTC_EUR

# Import data from Exchange
MODE=import ./main.py BTC_EUR

# Backtest with an imported dataset or Binance Exchange API
MODE=backtest ./main.py BTC_EUR

您可以轻松地覆盖任何设置，如下所示：

PERIOD_START="2021-04-16 00:00" PERIOD_END="2021-04-16 00:00" STRATEGY=myCustomStrategy MODE=backtest ./main.py BTC_EUR

要退出测试模式并进行真实交易，只需将“ trading_mode”从“ test”切换为“ real”。谨慎使用，后果自负。

TRADING_MODE=real ./main.py BTC_EUR

集成化项目

我们可以使用Docker对该程序进行容器化。这是一个简单的自我解释Docker构建文件的例子。

FROM python:3.9

WORKDIR /usr/src/app

COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD [ "python", "./main.py" ]

基准

使用带有16go DDR3 ram的旧AMD Phenom II 955四核CPU，并运行其他进程。

导入

导入价格并将其部署到内部API

1天的行情

Execution time: 82.716666 seconds

一周的行情

Execution time: 9,423079183 minutes

一个月的行情

Execution time: 27,48139456 minutes

六个月的行情

Execution time: 3.032364739 hours

回测

从导入的数据集

1天的行情

Execution time: 3.746787 seconds

一周的行情

Execution time: 46.900068 seconds

一个月的行情

Execution time: 1.8953 seconds

六个月的行情

Execution time: 12,15175435 minutes

结论

我们构建了一个kickass性能的实时加密交易机器人。他能够使用少量的CPU和RAM在大型市场数据集上对您的策略进行回测。从交易所导入数据集，甚至使用WebSocket实时执行实时交易。

更进一步

• 编写一个涵盖所有程序行为的测试套件，以确保将来不会退化。

• 构建并使用内部Rest API实时持久保存所有加密货币交易所市场数据。

• 建立最终用户客户端，例如移动应用或网络应用。使用WebSocket或服务器发送事件，以显示实时指标。

感谢您阅读这三部分的文章，内容涉及如何使用python 3和Binance API构建加密机器人。

在本系列的第一部分中，我们讨论了文件夹结构，添加了我们的第一个Price业务对象，并为策略抽象层进行编码。

下面将通过编码我们需要的货币和订单的业务对象开始。

此处，货币业务对象存储所有不同的加密货币或法定货币。

./models/order.py

from models.model import AbstractModel


class Currency(AbstractModel):
    name: str = ''
    symbol: str = ''
    fiat: bool

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

然后是订单业务对象处理我们在交易所创建的订单。

./models/order.py

from models.model import AbstractModel


class Order(AbstractModel):
    BUY = 'BUY'
    SELL = 'SELL'

    TYPE_LIMIT = 'LIMIT'
    TYPE_MARKET = 'MARKET'
    TYPE_STOP_LOSS = 'STOP_LOSS'
    TYPE_STOP_LOSS_LIMIT = 'STOP_LOSS_LIMIT'
    TYPE_TAKE_PROFIT = 'TAKE_PROFIT'
    TYPE_TAKE_PROFIT_LIMIT = 'TAKE_PROFIT_LIMIT'
    TYPE_LIMIT_MAKER = 'LIMIT_MAKER'

    uuid = ''
    side: str = ''
    type: str = TYPE_LIMIT
    symbol: str = ''
    currency: str = ''
    asset: str = ''
    price: float = 0
    quantity: int = 0
    test: bool = False

    def __init__(self, **kwargs):
        super().__init__(**kwargs)

然后构建交换抽象层，并开发我们的第一个连接器。由于这里不是编写API包装器的重点，因此为了方便起见，我们将使用非官方的Binance API包装器库python-binance（https://python-binance.readthedocs.io/en/latest/binance.html）。

./exchanges/exchange.py

import datetime
from api import utils
from abc import ABC, abstractmethod
from twisted.internet import reactor
from strategies.strategy import Strategy
from models.order import Order


class Exchange(ABC):
    currency: str
    asset: str
    strategy: Strategy

    def __init__(self, key: str, secret: str):
        self.apiKey = key
        self.apiSecret = secret
        self.name = None
        self.client = None
        self.socketManager = None
        self.socket = None
        self.currency = ''
        self.asset = ''
        self.strategy = None

    def set_currency(self, symbol: str):
        self.currency = symbol

    def set_asset(self, symbol: str):
        self.asset = symbol

    def set_strategy(self, strategy: Strategy):
        self.strategy = strategy

    def compute_symbol_pair(self):
        return utils.format_pair(self.currency, self.asset)

    # abstract methods

    # Override to set current exchange symbol pair notation (default with _ separator currency_asset ex: eur_btc)
    @abstractmethod
    def get_symbol(self):
        return self.compute_symbol_pair(self)

    # Get current symbol ticker
    @abstractmethod
    def symbol_ticker(self):
        pass

    # Get current symbol ticker candle for given interval
    @abstractmethod
    def symbol_ticker_candle(self, interval):
        pass

    # Get current symbol historic value
    @abstractmethod
    def historical_symbol_ticker_candle(self, start: datetime, end=None, interval=60):
        pass

    # Get balance for a given currency
    @abstractmethod
    def get_asset_balance(self, currency):
        pass

    # Create an exchange order
    @abstractmethod
    def order(self, order: Order):
        pass

    # Create an exchange test order
    @abstractmethod
    def test_order(self, order: Order):
        pass

    # Check an exchange order status
    @abstractmethod
    def check_order(self, orderId):
        pass

    # Cancel an exchange order
    @abstractmethod
    def cancel_order(self, orderId):
        pass

    # WebSocket related methods

    @abstractmethod
    def get_socket_manager(self, purchase):
        pass

    @abstractmethod
    def websocket_event_handler(self, msg):
        pass

    def start_socket(self):
        print('Starting WebSocket connection...')
        self.socketManager.start()

    def close_socket(self):
        self.socketManager.stop_socket(self.socket)
        self.socketManager.close()
        # properly terminate WebSocket
        reactor.stop()

    @abstractmethod
    def start_symbol_ticker_socket(self, symbol: str):
        pass

我们的第一个Binance API连接器。

./exchanges/binance.py

from datetime import datetime
from math import floor

from binance.client import Client
from binance.enums import *
from binance.websockets import BinanceSocketManager

from api import utils
from exchanges import exchange
from models.order import Order
from models.price import Price


class Binance(exchange.Exchange):
    def __init__(self, key: str, secret: str):
        super().__init__(key, secret)

        self.client = Client(self.apiKey, self.apiSecret)
        self.name = self.__class__.__name__

    def get_client(self):
        return self.client

    def get_symbol(self):
        return self.currency + self.asset

    def symbol_ticker(self):
        response = self.client.get_symbol_ticker(symbol=self.get_symbol())
        return Price(pair=self.get_symbol(), currency=self.currency.lower(), asset=self.asset.lower(), exchange=self.name.lower(),
                     current=response['price'])

    def symbol_ticker_candle(self, interval=Client.KLINE_INTERVAL_1MINUTE):
        return self.client.get_klines(symbol=self.get_symbol(), interval=interval)

    def historical_symbol_ticker_candle(self, start: datetime, end=None, interval=Client.KLINE_INTERVAL_1MINUTE):
        # Convert default seconds interval to string like "1m"
        if isinstance(interval, int):
            interval = str(floor(interval/60)) + 'm'

        output = []
        for candle in self.client.get_historical_klines_generator(self.get_symbol(), interval, start, end):
            output.append(
                Price(pair=self.compute_symbol_pair(), currency=self.currency.lower(), asset=self.asset.lower(), exchange=self.name.lower(),
                      current=candle[1], lowest=candle[3], highest=candle[2], volume=candle[5], openAt=utils.format_date(datetime.fromtimestamp(int(candle[0])/1000)))
            )

        return output

    def get_asset_balance(self, currency):
        response = self.client.get_asset_balance(currency)
        return response['free']

    def order(self, order: Order):
        return self.client.create_order(
            symbol=order.symbol,
            side=order.side,
            type=order.type,
            timeInForce=TIME_IN_FORCE_GTC,
            quantity=order.quantity,
            price=order.price
        )

    def test_order(self, order: Order):
        return self.client.create_test_order(
            symbol=order.symbol,
            side=order.side,
            type=order.type,
            timeInForce=TIME_IN_FORCE_GTC,
            quantity=order.quantity,
            price=order.price
        )

    def check_order(self, orderId):
        return self.client.get_order(
            symbol=self.get_symbol(),
            orderId=orderId
        )

    def cancel_order(self, orderId):
        return self.client.cancel_order(
            symbol=self.get_symbol(),
            orderId=orderId
        )

    def get_socket_manager(self):
        return BinanceSocketManager(self.client)

    def start_symbol_ticker_socket(self, symbol: str):
        self.socketManager = self.get_socket_manager()
        self.socket = self.socketManager.start_symbol_ticker_socket(
            symbol=self.get_symbol(),
            callback=self.websocket_event_handler
        )

        self.start_socket()

    def websocket_event_handler(self, msg):
        if msg['e'] == 'error':
            print(msg)
            self.close_socket()
        else:
            self.strategy.set_price(
                Price(pair=self.compute_symbol_pair(), currency=self.currency, asset=self.asset, exchange=self.name,
                      current=msg['b'], lowest=msg['l'], highest=msg['h'])
            )
            self.strategy.run()

现在，只需调用我们的策略启动方法，我们便拥有了一个极简而强大的交易机器人系统。使用自己的指标和策略，您可以通过传递订单来开始买卖。但是，在开始编写自己的策略代码之前，请确保对其进行测试并安全运行。所以你需要一个系统来做到这一点。

在下一部分中，我们将实现回测模式，以针对交易所的历史数据来测试您的策略，并提供导入这些数据的服务。

另外，我们将所有这些部分与全局配置和一些依赖项一起打包进命令行工具中。

最后我们将通过查看如何对该代码进行容器化和工业化实现来进一步介绍。

交易数字货币或任何其他资产的首要任务是要有目标和策略来实现。在这里，我们不是在谈论交易策略，而只是构建一个简单而功能强大的数字货币交易机器人来应用您的策略。本系列更像是一个数字货币自动交易机器人框架。

我们将使用python 3.9（3.9.2）首先创建项目文件结构。

/exchanges

/strategies

/models

在这里，“ exchanges”文件夹存储了Exchange API包装器，为您的策略制定策略并为我们将要使用的业务对象建模。

模型

我们将为此项目定义几个业务对象，例如价格，货币类型或订单。首先，让我们从价格开始，将其用于我们随后将要创建的策略。

在我们为业务对象编写通用抽象层之前：

./models/model.py

from datetime import datetime


class AbstractModel:
    created: datetime

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

然后是我们的第一个Price类：

./models/price

from models.model import AbstractModel


class Price(AbstractModel):
    pair: str = ''
    exchange: str = ''
    current: float = 0
    lowest: float = 0
    highest: float = 0
    currency: str = ''
    asset: str = ''

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.pair = self.get_pair()

    def get_pair(self):
        return self.currency + '_' + self.asset

策略部分

这个系统的最大部分——策略将负责运行您的交易逻辑。有两种方法，一种是经典的利用时间间隔然后运行对外部交易所API的调用，或者运行内部webhooks、路由，以及 使用WebSocket的实时事件。

为此，我们将首先创建一个抽象策略类，该策略类将进行扩展。

./strategies/strategy.py

import json
import threading
import time
from datetime import datetime
from decouple import config
from models.price import Price


class Strategy(object):
    price: Price

    def __init__(self, exchange, interval=60, *args, **kwargs):
        self._timer = None
        self.interval = interval
        self.args = args
        self.kwargs = kwargs
        self.is_running = False
        self.next_call = time.time()
        self.portfolio = {}
        self.exchange = exchange
        # Load account portfolio for pair at load
        self.get_portfolio()

    def _run(self):
        self.is_running = False
        self.start()
        self.run(*self.args, **self.kwargs)

    def start(self):
        if not self.is_running:
            print(datetime.now())
            if self._timer is None:
                self.next_call = time.time()
            else:
                self.next_call += self.interval

            self._timer = threading.Timer(self.next_call - time.time(), self._run)
            self._timer.start()
            self.is_running = True

    def stop(self):
        self._timer.cancel()
        self.is_running = False

    def get_portfolio(self):
        self.portfolio = {'currency': self.exchange.get_asset_balance(self.exchange.currency),
                          'asset': self.exchange.get_asset_balance(self.exchange.asset)}

    def get_price(self):
        try:
            self.price = self.exchange.symbol_ticker()
        except Exception as e:
            pass

...

在这里，我们的策略抽象层构造函数签名需要一个Exchange实例，我们将在稍后使用Binance API编写第一个包装器来完成这一部分。

我们在没有任何额外库的情况下定义了一个简单但功能强大的无限间隔运行器，请注意，每次运行都会在另一个线程上启动下一个调用，但是实际上，您的策略将永远使用不超过两个线程，如果您使用一个主线程和当前运行策略需要大量的外部调用或繁重的计算。每个线程消耗0.3％的RAM和0或0.1 的CPU使用率，这还涉及以下策略：获取报价单和订单，然后将价格和订单相关的数据存储在另一个内部API中。

虽然间隔运行精度可以在微秒上漂移一点，但是在秒级别上将保持稳定。

这是该层的简单用法，它是一种基本打印您的兑换账户投资组合和兑换价格的策略。我们提供了一种方法，该方法可以从以后要连接的外部交易所中检索交易品种代码，还可以找到一种方法来检索您在已连接的交易所中可用的当前投资组合。

./strategies/watcher.py

from exchanges.exchange import Exchange
from strategies.strategy import Strategy


class Watcher(Strategy):
    def __init__(self, exchange: Exchange, timeout=60, *args, **kwargs):
        super().__init__(exchange, timeout, *args, **kwargs)

    def run(self):
        self.get_price()
        print('*******************************')
        print('Exchange: ', self.exchange.name)
        print('Pair: ', self.exchange.get_symbol())
        print('Available: ', self.portfolio['currency'] + ' ' + self.exchange.currency)
        print('Available: ', self.portfolio['asset'] + ' ' + self.exchange.asset)
        print('Price: ', self.price.current)

在接下来的部分中，我们将通过使用币安官方API：

https://github.com/binance/binance/binance-spot-api-docs

和Python request库：

https://pypi.org/project/requests/

对一个简单的策略进行编码，来连接我们的第一个Exchange Binance。然后，对业务对象订单和货币进行编码，以分别存储您发送给交易所的订单和我们将要操作的法定货币或数字货币，然后将所有这些不同的货币放在一起。

感谢您的阅读，敬请期待下一部分。