27、利用IPFS实现去中心化视频分享应用

最新推荐文章于 2025-11-27 05:34:13 发布

open4

最新推荐文章于 2025-11-27 05:34:13 发布

阅读量47

点赞数

CC 4.0 BY-SA版权

分类专栏： Python开发者实战区块链：从入门到精通文章标签： IPFS 去中心化视频分享智能合约

本文链接：https://blog.youkuaiyun.com/open4/article/details/149856049

Python开发者实战区块链：从入门到精通专栏收录该内容

29 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

利用IPFS实现去中心化视频分享应用

在当今数字化时代，去中心化应用逐渐崭露头角，为我们带来了更加安全、民主的互联网体验。本文将详细介绍如何利用IPFS实现一个去中心化的视频分享应用，包括智能合约和Web应用的架构设计，以及具体的代码实现和测试。

1. 应用概述与优势

我们要构建的视频分享应用具有两大主要特点：
- 加密经济 ：在智能合约中引入经济活动，如买卖、竞价等，并创建代币。用户可以使用代币来点赞视频，点赞不再免费，视频所有者可以将这些代币兑换成实际收益。这种机制激励用户上传更高质量的视频。
- API独立性 ：去中心化应用保证了API的独立性，避免了像Twitter API那样受到干扰或限制。开发者可以更自由地使用API，不用担心平台突然施加的限制。

应用的主要功能包括：
- 查看视频列表、播放视频和上传视频，类似于YouTube的基本功能。
- 使用代币点赞视频。

2. 视频分享智能合约架构

智能合约是应用的核心，它需要完成以下几个任务：
- 跟踪用户上传的视频。
- 利用代币及其标准操作（ERC20）。
- 提供用户使用代币点赞视频的方式。
- 将点赞视频所使用的代币转移给视频所有者。

为了减少智能合约出现漏洞的风险，我们应尽量保持代码简洁。在设计智能合约的数据结构时，我们需要考虑如何跟踪用户的视频。具体来说，我们使用一个以地址为键的映射变量，其值是另一个映射变量（mapping z）。mapping z以整数为键，以包含IPFS路径和视频标题的结构体为值。同时，我们使用一个整数跟踪器来记录每个用户上传视频的索引。

对于点赞功能，我们使用两个映射变量：
- likes_videos ：以 bytes[100] 为键，布尔值为值，用于检查用户是否已经点赞过某个视频。
- aggregate_likes ：以 bytes[100] 为键，整数为值，用于记录某个视频的总点赞数。

为了确保用户不能重复点赞同一个视频，我们在智能合约中进行了相应的检查。同时，虽然跟踪具体哪些用户点赞了某个视频会使智能合约变得复杂，但我们可以通过智能合约中的事件来实现这一功能。具体做法是，每次用户点赞视频时触发一个事件，然后在客户端使用 web3.py 库过滤这些事件，获取所有点赞某个视频的用户。这是一个较为昂贵的过程，可以使用Celery进行后台任务处理，并将结果存储在SQLite、PostgreSQL或MySQL等数据库中。

以下是智能合约的部分代码示例：

struct Video:
    path: bytes[50]
    title: bytes[20]

Transfer: event({_from: indexed(address), _to: indexed(address), _value: uint256})
Approval: event({_owner: indexed(address), _spender: indexed(address), _value: uint256})
UploadVideo: event({_user: indexed(address), _index: uint256})
LikeVideo: event({_video_liker: indexed(address), _video_uploader: indexed(address), _index: uint256})

user_videos_index: map(address, uint256)
name: public(bytes[20])
symbol: public(bytes[3])
totalSupply: public(uint256)
decimals: public(uint256)
balances: map(address, uint256)
allowed: map(address, map(address, uint256))
all_videos: map(address, map(uint256, Video))
likes_videos: map(bytes[100], bool)
aggregate_likes: map(bytes[100], uint256)

@public
def __init__():
    _initialSupply: uint256 = 500
    _decimals: uint256 = 3
    self.totalSupply = _initialSupply * 10 ** _decimals
    self.balances[msg.sender] = self.totalSupply
    self.name = 'Video Sharing Coin'
    self.symbol = 'VID'
    self.decimals = _decimals
    log.Transfer(ZERO_ADDRESS, msg.sender, self.totalSupply)

@public
@constant
def allowance(_owner: address, _spender: address) -> uint256:
    return self.allowed[_owner][_spender]

@private
def _transfer(_source: address, _to: address, _amount: uint256) -> bool:
    assert self.balances[_source] >= _amount
    self.balances[_source] -= _amount
    self.balances[_to] += _amount
    log.Transfer(_source, _to, _amount)
    return True

@public
def transfer(_to: address, _amount: uint256) -> bool:
    return self._transfer(msg.sender, _to, _amount)

@public
def upload_video(_video_path: bytes[50], _video_title: bytes[20]) -> bool:
    _index: uint256 = self.user_videos_index[msg.sender]
    self.all_videos[msg.sender][_index] = Video({ path: _video_path, title: _video_title })
    self.user_videos_index[msg.sender] += 1
    log.UploadVideo(msg.sender, _index)
    return True

@public
@constant
def latest_videos_index(_user: address) -> uint256:
    return self.user_videos_index[_user]

@public
@constant
def videos_path(_user: address, _index: uint256) -> bytes[50]:
    return self.all_videos[_user][_index].path

@public
@constant
def videos_title(_user: address, _index: uint256) -> bytes[20]:
    return self.all_videos[_user][_index].title

@public
def like_video(_user: address, _index: uint256) -> bool:
    _msg_sender_str: bytes32 = convert(msg.sender, bytes32)
    _user_str: bytes32 = convert(_user, bytes32)
    _index_str: bytes32 = convert(_index, bytes32)
    _key: bytes[100] = concat(_msg_sender_str, _user_str, _index_str)
    _likes_key: bytes[100] = concat(_user_str, _index_str)
    assert _index < self.user_videos_index[_user]
    assert self.likes_videos[_key] == False
    self.likes_videos[_key] = True
    self.aggregate_likes[_likes_key] += 1
    self._transfer(msg.sender, _user, 1)
    log.LikeVideo(msg.sender, _user, _index)
    return True

@public
@constant
def video_has_been_liked(_user_like: address, _user_video: address, _index: uint256) -> bool:
    _user_like_str: bytes32 = convert(_user_like, bytes32)
    _user_video_str: bytes32 = convert(_user_video, bytes32)
    _index_str: bytes32 = convert(_index, bytes32)
    _key: bytes[100] = concat(_user_like_str, _user_video_str, _index_str)
    return self.likes_videos[_key]

@public
@constant
def video_aggregate_likes(_user_video: address, _index: uint256) -> uint256:
    _user_video_str: bytes32 = convert(_user_video, bytes32)
    _index_str: bytes32 = convert(_index, bytes32)
    _key: bytes[100] = concat(_user_video_str, _index_str)
    return self.aggregate_likes[_key]

3. 视频分享Web应用架构

我们将开发一个Python Web应用作为智能合约的前端。为了运行这个应用，我们至少需要一个Gunicorn Web服务器，并将其部署在AWS、GCP或Azure等中心化服务器上。然而，当用户上传视频时，需要访问私钥，这可能会让用户担心私钥被盗取。

为了解决这个问题，我们可以将Python Web应用的源代码发布到GitHub或GitLab上，让用户下载、安装并在自己的计算机上运行。用户可以审核源代码，确保没有恶意代码。更好的做法是将源代码存储在IPFS上，用户从IPFS下载后可以确保代码不会被篡改，只需在使用前审核一次。

需要注意的是，虽然可以在IPFS上托管静态网站，但Python、PHP、Ruby或Perl等动态网页应用需要一个合适的Web服务器。因此，下载源代码的用户需要安装Python解释器、Web服务器（如Gunicorn、Apache或NGINX）以及所有必要的库。此外，由于Android或iOS平台上没有合适的Python解释器或Web服务器，移动用户无法直接运行这个Python Web应用。相比之下，JavaScript可以创建动态的静态网站，并且可以使用React.js、Angular.js、Ember.js或Vue.js等框架构建复杂的Web应用，并部署在IPFS上，桌面和移动用户都可以运行。

Web应用的主要功能及其参数如下：
| 功能 | 参数 | 说明 |
| ---- | ---- | ---- |
| 播放视频 | 视频上传者地址、视频索引 | 如果视频不在本地存储，从IPFS下载并播放 |
| 上传视频 | 账户地址、加密私钥密码、视频文件、视频标题 | 先将视频文件存储在IPFS上，成功后将视频信息存储在区块链上 |
| 点赞视频 | 点赞者地址、加密私钥密码、视频上传者地址、视频索引 | 确保用户未点赞过该视频后，将信息存储在区块链上 |
| 列出多个用户的最近视频 | 无 | 通过区块链上存储视频信息的事件查找最近视频 |
| 列出特定用户的视频 | 用户地址 | 根据智能合约中的映射变量获取用户的视频列表 |

4. 智能合约开发平台搭建

在开始编写智能合约之前，我们需要搭建开发平台，具体步骤如下：
1. 创建虚拟环境 ：

$ virtualenv -p python3.6 videos-venv
$ source videos-venv/bin/activate
(videos-venv) $

安装必要的库 ：

(videos-venv) $ pip install eth-abi==1.2.2
(videos-venv) $ pip install eth-typing==1.1.0
(videos-venv) $ pip install py-evm==0.2.0a33
(videos-venv) $ pip install web3==4.7.2
(videos-venv) $ pip install -e git+https://github.com/ethereum/populus#egg=populus
(videos-venv) $ pip install vyper

检查并修复Populus库的Bug ：

(videos-venv) $ cd videos-venv/src/populus
(videos-venv) $ grep -R "compile(" populus/compilation/backends/vyper.py

如果发现Bug未修复，可以使用以下命令进行补丁：

(videos-venv) $ wget https://patch-diff.githubusercontent.com/raw/ethereum/populus/pull/484.patch
(videos-venv) $ git apply 484.patch
(videos-venv) $ cd ../../../

(videos-venv) $ mkdir videos-sharing-smart-contract

(videos-venv) $ cd videos-sharing-smart-contract
(videos-venv) $ mkdir contracts tests

下载Populus配置文件 ：

(videos-venv) $ wget https://raw.githubusercontent.com/ethereum/populus/master/populus/assets/defaults.v9.config.json -O project.json

修改配置文件 ：
打开 project.json 文件，覆盖 compilation 键的值如下：

{
    "compilation": {
        "backend": {
            "class": "populus.compilation.backends.VyperBackend"
        },
        "contract_source_dirs": [
            "./contracts"
        ],
        "import_remappings": []
    }
}

编写智能合约代码 ：
在 videos-sharing-smart-contract/contracts/VideosSharing.vy 文件中编写智能合约代码，具体代码如前面所示。

5. 测试智能合约

为了确保智能合约的正确性，我们需要编写测试脚本。以下是测试脚本的部分代码：

import pytest
import eth_tester

def upload_video(video_sharing, chain, account, video_path, video_title):
    txn_hash = video_sharing.functions.upload_video(video_path, video_title).transact({'from': account})
    chain.wait.for_receipt(txn_hash)

def transfer_coins(video_sharing, chain, source, destination, amount):
    txn_hash = video_sharing.functions.transfer(destination, amount).transact({'from': source})
    chain.wait.for_receipt(txn_hash)

def like_video(video_sharing, chain, video_liker, video_uploader, index):
    txn_hash = video_sharing.functions.like_video(video_uploader, index).transact({'from': video_liker})
    chain.wait.for_receipt(txn_hash)

def test_upload_video(web3, chain):
    video_sharing, _ = chain.provider.get_or_deploy_contract('VideosSharing')
    t = eth_tester.EthereumTester()
    video_uploader = t.get_accounts()[1]
    index = video_sharing.functions.latest_videos_index(video_uploader).call()
    assert index == 0
    upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path', b"video title")
    index = video_sharing.functions.latest_videos_index(video_uploader).call()
    assert index == 1
    path = video_sharing.functions.videos_path(video_uploader, 0).call()
    assert path == b'video-ipfs-path'
    title = video_sharing.functions.videos_title(video_uploader, 0).call()
    assert title == b"video title"
    upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path2', b"video title2")
    index = video_sharing.functions.latest_videos_index(video_uploader).call()
    assert index == 2
    path = video_sharing.functions.videos_path(video_uploader, 1).call()
    assert path == b'video-ipfs-path2'
    title = video_sharing.functions.videos_title(video_uploader, 1).call()
    assert title == b"video title2"
    events = chain.wait.for_receipt(video_sharing.address).logs
    assert events[0]['args']['_user'] == video_uploader
    assert events[0]['args']['_index'] == 0
    assert events[1]['args']['_user'] == video_uploader
    assert events[1]['args']['_index'] == 1

def test_like_video(web3, chain):
    video_sharing, _ = chain.provider.get_or_deploy_contract('VideosSharing')
    t = eth_tester.EthereumTester()
    manager = t.get_accounts()[0]
    video_uploader = t.get_accounts()[1]
    video_liker = t.get_accounts()[2]
    video_liker2 = t.get_accounts()[3]
    transfer_coins(video_sharing, chain, manager, video_liker, 100)
    transfer_coins(video_sharing, chain, manager, video_liker2, 100)
    transfer_coins(video_sharing, chain, manager, video_uploader, 50)
    upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path', b"video title")
    assert video_sharing.functions.balances(video_liker).call() == 100
    assert video_sharing.functions.balances(video_uploader).call() == 50
    assert video_sharing.functions.video_has_been_liked(video_liker, video_uploader, 0).call() == False
    assert video_sharing.functions.video_aggregate_likes(video_uploader, 0).call() == 0
    like_video(video_sharing, chain, video_liker, video_uploader, 0)
    assert video_sharing.functions.balances(video_liker).call() == 99
    assert video_sharing.functions.balances(video_uploader).call() == 51
    assert video_sharing.functions.video_has_been_liked(video_liker, video_uploader, 0).call() == True
    assert video_sharing.functions.video_aggregate_likes(video_uploader, 0).call() == 1
    with pytest.raises(eth_tester.exceptions.TransactionFailed):
        like_video(video_sharing, chain, video_liker, video_uploader, 0)

6. 总结

通过以上步骤，我们详细介绍了如何利用IPFS实现一个去中心化的视频分享应用。从智能合约的架构设计到Web应用的部署，再到具体的代码实现和测试，每个环节都至关重要。在开发过程中，我们需要考虑数据结构的设计、智能合约的安全性以及用户体验等因素。同时，要注意不同平台的局限性，如移动平台对Python Web应用的支持不足。希望本文能为你开发去中心化应用提供有益的参考。

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;

    A(搭建开发平台):::process --> B(设计智能合约架构):::process
    B --> C(编写智能合约代码):::process
    C --> D(部署智能合约):::process
    D --> E(开发Web应用):::process
    E --> F(测试智能合约和Web应用):::process
    F --> G(部署Web应用):::process

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;

    A(用户上传视频):::process --> B(视频存储在IPFS):::process
    B --> C(视频信息存储在区块链):::process
    D(用户点赞视频):::process --> E(检查是否已点赞):::process
    E -->|未点赞| F(更新点赞信息和代币余额):::process
    E -->|已点赞| G(拒绝点赞请求):::process
    F --> H(记录点赞事件):::process

利用IPFS实现去中心化视频分享应用

7. 智能合约测试脚本解析

测试脚本是确保智能合约功能正确性的关键，下面我们详细解析测试脚本中的各个函数和测试用例。

辅助函数
- upload_video ：该函数用于上传视频。它接收智能合约实例、区块链实例、账户地址、视频路径和视频标题作为参数。通过调用智能合约的 upload_video 方法并等待交易回执，确保视频信息成功存储在区块链上。
  python def upload_video(video_sharing, chain, account, video_path, video_title): txn_hash = video_sharing.functions.upload_video(video_path, video_title).transact({'from': account}) chain.wait.for_receipt(txn_hash)
- transfer_coins ：此函数用于转移代币。接收智能合约实例、区块链实例、源账户地址、目标账户地址和转移金额作为参数。调用智能合约的 transfer 方法并等待交易回执，完成代币转移。
  python def transfer_coins(video_sharing, chain, source, destination, amount): txn_hash = video_sharing.functions.transfer(destination, amount).transact({'from': source}) chain.wait.for_receipt(txn_hash)
- like_video ：该函数用于点赞视频。接收智能合约实例、区块链实例、点赞者地址、视频上传者地址和视频索引作为参数。调用智能合约的 like_video 方法并等待交易回执，实现点赞功能。
  python def like_video(video_sharing, chain, video_liker, video_uploader, index): txn_hash = video_sharing.functions.like_video(video_uploader, index).transact({'from': video_liker}) chain.wait.for_receipt(txn_hash)
测试用例
- test_upload_video ：该测试用例用于测试视频上传功能。首先获取智能合约实例和测试账户，检查初始视频索引是否为0。然后上传一个视频，检查视频索引是否增加，视频路径和标题是否正确。再次上传一个视频，重复检查操作。最后检查上传视频事件的信息是否正确。
  python def test_upload_video(web3, chain): video_sharing, _ = chain.provider.get_or_deploy_contract('VideosSharing') t = eth_tester.EthereumTester() video_uploader = t.get_accounts()[1] index = video_sharing.functions.latest_videos_index(video_uploader).call() assert index == 0 upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path', b"video title") index = video_sharing.functions.latest_videos_index(video_uploader).call() assert index == 1 path = video_sharing.functions.videos_path(video_uploader, 0).call() assert path == b'video-ipfs-path' title = video_sharing.functions.videos_title(video_uploader, 0).call() assert title == b"video title" upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path2', b"video title2") index = video_sharing.functions.latest_videos_index(video_uploader).call() assert index == 2 path = video_sharing.functions.videos_path(video_uploader, 1).call() assert path == b'video-ipfs-path2' title = video_sharing.functions.videos_title(video_uploader, 1).call() assert title == b"video title2" events = chain.wait.for_receipt(video_sharing.address).logs assert events[0]['args']['_user'] == video_uploader assert events[0]['args']['_index'] == 0 assert events[1]['args']['_user'] == video_uploader assert events[1]['args']['_index'] == 1
- test_like_video ：该测试用例用于测试视频点赞功能。首先转移代币到不同账户，上传一个视频。然后检查账户代币余额、视频是否被点赞以及点赞总数是否正确。接着进行点赞操作，再次检查账户代币余额、视频是否被点赞以及点赞总数是否更新。最后尝试重复点赞，确保会抛出交易失败异常。
  python def test_like_video(web3, chain): video_sharing, _ = chain.provider.get_or_deploy_contract('VideosSharing') t = eth_tester.EthereumTester() manager = t.get_accounts()[0] video_uploader = t.get_accounts()[1] video_liker = t.get_accounts()[2] video_liker2 = t.get_accounts()[3] transfer_coins(video_sharing, chain, manager, video_liker, 100) transfer_coins(video_sharing, chain, manager, video_liker2, 100) transfer_coins(video_sharing, chain, manager, video_uploader, 50) upload_video(video_sharing, chain, video_uploader, b'video-ipfs-path', b"video title") assert video_sharing.functions.balances(video_liker).call() == 100 assert video_sharing.functions.balances(video_uploader).call() == 50 assert video_sharing.functions.video_has_been_liked(video_liker, video_uploader, 0).call() == False assert video_sharing.functions.video_aggregate_likes(video_uploader, 0).call() == 0 like_video(video_sharing, chain, video_liker, video_uploader, 0) assert video_sharing.functions.balances(video_liker).call() == 99 assert video_sharing.functions.balances(video_uploader).call() == 51 assert video_sharing.functions.video_has_been_liked(video_liker, video_uploader, 0).call() == True assert video_sharing.functions.video_aggregate_likes(video_uploader, 0).call() == 1 with pytest.raises(eth_tester.exceptions.TransactionFailed): like_video(video_sharing, chain, video_liker, video_uploader, 0)

8. 部署与优化建议

部署建议
- 智能合约部署 ：在部署智能合约时，选择合适的以太坊网络，如测试网络（如Ropsten、Kovan等）进行测试，确保合约功能正常后再部署到主网。同时，注意部署时的Gas费用，合理设置Gas价格和Gas上限，避免因Gas不足导致交易失败或因Gas价格过高造成不必要的损失。
- Web应用部署 ：对于Python Web应用，将其部署在稳定的中心化服务器上，如AWS、GCP或Azure。可以使用负载均衡器来提高应用的可用性和性能。此外，将应用源代码存储在IPFS上，方便用户获取和审核，增强用户信任。
优化建议
- 智能合约优化 ：减少智能合约的代码行数，避免复杂的逻辑和嵌套循环，降低合约的复杂度，减少潜在的漏洞。同时，合理使用事件来记录重要信息，方便后续的查询和分析。
- Web应用优化 ：对于视频播放功能，可以采用缓存技术，将经常播放的视频缓存到本地，减少从IPFS下载的次数，提高播放速度。对于用户上传视频功能，可以采用异步处理的方式，避免阻塞主线程，提高用户体验。

9. 未来展望

随着区块链技术和IPFS的不断发展，去中心化视频分享应用有着广阔的发展前景。未来可以考虑以下几个方面的扩展：
- 社交功能扩展 ：增加评论、分享、关注等社交功能，增强用户之间的互动，提高用户粘性。
- 内容审核机制 ：引入基于区块链的内容审核机制，确保平台上的视频内容符合规定，提高平台的安全性和可信度。
- 跨链互操作性 ：实现与其他区块链的互操作性，让用户可以在不同的区块链之间进行代币转移和视频分享，扩大应用的影响力。

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;

    A(测试辅助函数):::process --> B(测试上传视频功能):::process
    B --> C(测试点赞视频功能):::process
    C --> D(检查账户余额和点赞信息):::process
    D --> E(验证交易结果):::process

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;

    A(智能合约部署):::process --> B(选择合适网络):::process
    B --> C(设置Gas费用):::process
    D(Web应用部署):::process --> E(选择稳定服务器):::process
    E --> F(使用负载均衡器):::process
    G(智能合约优化):::process --> H(减少代码复杂度):::process
    H --> I(合理使用事件):::process
    J(Web应用优化):::process --> K(采用缓存技术):::process
    K --> L(异步处理上传):::process

综上所述，利用IPFS实现去中心化视频分享应用是一个具有创新性和挑战性的项目。通过合理的架构设计、代码实现和测试，以及不断的优化和扩展，我们可以打造一个安全、高效、民主的视频分享平台。希望本文能为开发者提供有益的参考，推动去中心化应用的发展。