IPFS文件地址链上存储

IPFS 是什么

IPFS（InterPlanetary File System，星际文件系统）是永久的、去中心化保存和共享文件的方法，这是一种内容可寻址、版本化、点对点超媒体的分布式协议。
内容可寻址：通过文件内容生成唯一哈希值来标识文件，而不是通过文件保存位置来标识。相同内容的文件在系统中只会存在一份，节约存储空间
版本化：可追溯文件修改历史
点对点超媒体：P2P 保存各种各样类型的数据
可以把 IPFS 想象成所有文件数据是在同一个 BitTorrent 群并且通过同一个 Git 仓库存取。
总之，它集一些成功系统（分布式哈希表、BitTorrent、Git、自认证文件系统）的优势于一身，是一套很厉害的文件存取系统。

区块链和IPFS的结合

大家都知道区块链的数据是可以永久保存的，但是如果在区块链上存储大量的数据是非常昂贵的。如果结合IPFS，我们可以在IPFS以文件的形式存储数据并把文件的地址保存在区块链上，这样就可以做到大量数据的永久存储并可以有效追踪。当然再结合区块链上的智能合约就可以发挥更大的想象力了。

IPFS地址分析

为了在链上存储IPFS的文件地址，我们对IPFS的文件地址做一下简单的分析。由于IPFS的数据块大小为256字节，因此如果文件大小超过此大小会被拆分为多个数据块。多个数据块要涉及到Merkle DAG(Directed Acyclic Graph) 默克有向无环图，相对复杂一点，后续的文章再做分析。这里我们简单分析一下单数据区块的情况。
从IPFS的源码分离出部分代码，可以生成文件的IPFS地址

 

function ipfsHash(filePath) {
    var buffer = fs.readFileSync(filePath);
    const unixFs = new Unixfs('file', buffer);
    DAGNode.create(unixFs.marshal(), (err, dagNode) => {
        let json = dagNode.toJSON();
        console.log("File:0x" + buffer.toString('hex'));
        console.log("UnixFs:0x" + unixFs.marshal().toString('hex'));
        console.log("Header+UnixFS:0x" + dagNode.serialized.toString('hex'));
        console.log("Multihash:0x" + dagNode.multihash.toString('hex'));
        console.log("Address:" + json.multihash);
        console.log("---------------------------------------------------------------------");
    });
}
ipfsHash('/Users/Kirn/Documents/Workspace/Dawn/ethereum/assets/test.txt');

File:0x310a320a330a340a350a360a370a0a
UnixFs:0x0802120f310a320a330a340a350a360a370a0a180f
Header+UnixFS:0x0a150802120f310a320a330a340a350a360a370a0a180f
Multihash:0x1220a1001394f749d9a0c5f27761b2f08e9432ce215dad6f01dbe26e468857169cbb
Address:QmZB8R7T5xvKJDUJ6pXtUym6frQx1r6bQPcwquR1rtGHL6

为了能更清楚的了解IPFS的地址构成我们把整个构造过程拆解一下

 

function customHash(filePath) {
    // 读取文件Buffer
    var buffer = fs.readFileSync(filePath);

    // 转为Unix File System
    const unixFs = new Unixfs('file', buffer).marshal();

    // 添加tag
    let tag = Buffer.from([10])
    
    // 添加File Size
    let size = Buffer.from([unixFs.length]);
    var newBuffer = Buffer.concat([tag, size, unixFs]);

    // sha2-256
    let sha256 = crypto.createHash('sha256').update(newBuffer).digest();

    // multihash
    let multihash = multihashes.encode(sha256, 'sha2-256');

    // base58
    let base58 = bs58.encode(multihash).toString('hex');
    console.log("File:0x" + buffer.toString('hex'));
    console.log("UnixFs:0x" + unixFs.toString('hex'));
    console.log("Header+UnixFS:0x" + newBuffer.toString('hex'));
    console.log("Sha256:0x" + sha256.toString('hex'));
    console.log("Multihash:0x" + multihash.toString('hex'));
    console.log("Address:" + base58);
    console.log("---------------------------------------------------------------------");
}
customHash('/Users/Kirn/Documents/Workspace/Dawn/ethereum/assets/test.txt');

File:0x310a320a330a340a350a360a370a0a
UnixFs:0x0802120f310a320a330a340a350a360a370a0a180f
Header+UnixFS:0x0a150802120f310a320a330a340a350a360a370a0a180f
Sha256:0xa1001394f749d9a0c5f27761b2f08e9432ce215dad6f01dbe26e468857169cbb
Multihash:0x1220a1001394f749d9a0c5f27761b2f08e9432ce215dad6f01dbe26e468857169cbb
Address:QmZB8R7T5xvKJDUJ6pXtUym6frQx1r6bQPcwquR1rtGHL6

大致可以分解为以下步骤

• 读取文件数据为Buffer
• 把文件数据转为Unix文件格式
• 数据流头部增加Metadata数据
  • tag: 0x0a=10（此处也不知为何，后续再做研究）
  • 文件大小
• sha2-256编码
• 转为multihash格式，目前IPFS采用的是32位sha2-256编码，因此数据头部需要增加0x1220，0x12代表sha256，0x20=32代表hash位数
• Base58编码

IPFS链上存储方案

针对于上面对IPFS地址的分析，我们可以在链上采取两种存取方案

• 存储方案一
  以string的形式直接存储IPFS地址，优点：简单明了，读取和存储都很方便，缺点：占用空间大，gas消耗可能会比较大
• 存储方案二
  以bytes32的形式只存储IPFS地址的sha256之后的结果，优点：占用空间少，gas消耗较少，缺点：读取和存储相对比较麻烦

写一个简单的合约测试一下

 

pragma solidity ^0.4.21;

contract IPFSAddress {
    mapping(address => bytes32) public bytesIpfs;
    mapping (address=>string) public stringIpfs;
    
    // save as bytes32
    function saveBytes(bytes32 ipfs) public {
        bytesIpfs[msg.sender] = ipfs;
    }
    
    // save as string 
    function saveString(string ipfs) public {
        stringIpfs[msg.sender] = ipfs;
    }
}

string存储交易回执

 

QmZB8R7T5xvKJDUJ6pXtUym6frQx1r6bQPcwquR1rtGHL6
{
  blockHash: "0x1385ab689055d504d98b675da4803708be856368e8dd2799a917b1153d5712e2",
  blockNumber: 185768,
  contractAddress: null,
  cumulativeGasUsed: 85962,
  from: "0x262bab6a90aa1741390c4a3ec58855c81d9728e1",
  gasUsed: 85962,
  logs: [],
  logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  root: "0xc37b7485014a3fc7ff943c4f753b77e649526633d490ca815ff2abd385699c88",
  to: "0xb6093ecf6a2ae6b94bb2e45186da0f2bcfa315a5",
  transactionHash: "0xfe6162aceeb211ace9b2c689135778ec28c1c5d778785f20a0a246220b18cfa4",
  transactionIndex: 0
}

bytes32存储交易回执

 

0xa1001394f749d9a0c5f27761b2f08e9432ce215dad6f01dbe26e468857169cbb
{
  blockHash: "0xf7f47ef6d77773b54fe143c933d67c49ee0694851bb7fa7cafb2b594d14c1d0e",
  blockNumber: 185766,
  contractAddress: null,
  cumulativeGasUsed: 43595,
  from: "0x262bab6a90aa1741390c4a3ec58855c81d9728e1",
  gasUsed: 43595,
  logs: [],
  logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  root: "0x476961f34dbbfc86c47a2f4935a5840b23fee03578994c56625ca83af75acf7f",
  to: "0xb6093ecf6a2ae6b94bb2e45186da0f2bcfa315a5",
  transactionHash: "0x0a8b740c94deae4df8df76852d03f74461843235e0c05b78f31c8f06ee2f81a3",
  transactionIndex: 0
}

对比两次链上交易的结果：

• string存储消耗：gasUsed: 85962
• bytes32存储消耗：gasUsed: 43595

bytes32存储差不多是string存储gas消耗的一半，算是一个较优的存储方案，当然前提是multihash采用的hash算法不变的情况下。因为IPFS的地址采用了multihash，在sha256算法不安全的情况下可以随时更换其他hash算法而不需要更改设计方案。

解析链上IPFS地址

为了方便查询链上的IPFS地址，可以把base58编码的算法在合约里实现一下，这里用library实现。

 

library IPFSLib {
    bytes constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

    /**
     * @dev Base58 encoding
     * @param _source Bytes data
     * @return Encoded bytes data
     */
    function base58Address(bytes _source) internal pure returns (bytes) {
        uint8[] memory digits = new uint8[](_source.length * 136/100 + 1);
        digits[0] = 0;
        uint8 digitlength = 1;
        for (uint i = 0; i < _source.length; ++i) {
            uint carry = uint8(_source[i]);
            for (uint j = 0; j<digitlength; ++j) {
                carry += uint(digits[j]) * 256;
                digits[j] = uint8(carry % 58);
                carry = carry / 58;
            }
            
            while (carry > 0) {
                digits[digitlength] = uint8(carry % 58);
                digitlength++;
                carry = carry / 58;
            }
        }
        return toAlphabet(reverse(truncate(digits, digitlength)));
    }

    /**
     * @dev Truncate `_array` by `_length`
     * @param _array The source array
     * @param _length The target length of the `_array`
     * @return The truncated array 
     */
    function truncate(uint8[] _array, uint8 _length) internal pure returns (uint8[]) {
        uint8[] memory output = new uint8[](_length);
        for (uint i = 0; i < _length; i++) {
            output[i] = _array[i];
        }
        return output;
    }
    
    /**
     * @dev Reverse `_input` array 
     * @param _input The source array 
     * @return The reversed array 
     */
    function reverse(uint8[] _input) internal pure returns (uint8[]) {
        uint8[] memory output = new uint8[](_input.length);
        for (uint i = 0; i < _input.length; i++) {
            output[i] = _input[_input.length - 1 - i];
        }
        return output;
    }

    /**
     * @dev Convert the indices to alphabet
     * @param _indices The indices of alphabet
     * @return The alphabets
     */
    function toAlphabet(uint8[] _indices) internal pure returns (bytes) {
        bytes memory output = new bytes(_indices.length);
        for (uint i = 0; i < _indices.length; i++) {
            output[i] = ALPHABET[_indices[i]];
        }
        return output;
    }

    /**
     * @dev Convert bytes32 to bytes
     * @param _input The source bytes32
     * @return The bytes
     */
    function toBytes(bytes32 _input) internal pure returns (bytes) {
        bytes memory output = new bytes(32);
        for (uint8 i = 0; i < 32; i++) {
            output[i] = _input[i];
        }
        return output;
    }

    /**
     * @dev Concat two bytes to one
     * @param _byteArray The first bytes
     * @param _byteArray2 The second bytes
     * @return The concated bytes
     */
    function concat(bytes _byteArray, bytes _byteArray2) internal pure returns (bytes) {
        bytes memory returnArray = new bytes(_byteArray.length + _byteArray2.length);
        for (uint16 i = 0; i < _byteArray.length; i++) {
            returnArray[i] = _byteArray[i];
        }
        for (i; i < (_byteArray.length + _byteArray2.length); i++) {
            returnArray[i] = _byteArray2[i - _byteArray.length];
        }
        return returnArray;
    }
}

 

contract IPFSAddress {
    using IPFSLib for bytes;
    using IPFSLib for bytes32;
    mapping(address => bytes32) public bytesIpfs;
    mapping (address=>string) public stringIpfs;
    
    function saveBytes(bytes32 ipfs) public {
        bytesIpfs[msg.sender] = ipfs;
    }
    
    function saveString(string ipfs) public {
        stringIpfs[msg.sender] = ipfs;
    }
    
    function ipfsAddress() external view returns (string) { 
        bytes memory prefix = new bytes(2);
        prefix[0] = 0x12;
        prefix[1] = 0x20;
        bytes memory value = prefix.concat(bytesIpfs[msg.sender].toBytes());
        bytes memory ipfsBytes = value.base58Address();
        return string(ipfsBytes);
    }
}

合约已部署Ropsten，可作参考

https://ropsten.etherscan.io/address/0x0581d89b0b4edf171a199937b1d16a1033ba7538

作者：Kirn
链接：https://www.jianshu.com/p/d16797e8de59
来源：简书