四大拜占庭容错变体简介 小蚁区块链独创dBFT机制
金色财经讯-在分布式系统中达成共识并不容易，这个问题通常被称为“拜占庭将军”问题，拜占庭故障时软件设计、流程、质量和软件应用中常见的故障。区块链技术应用程序从比特币的工作证明方法开始，如今正在为这一挑战提出解决方案。（区块链系统如何解决拜占庭将军问题 来源：金色财经）拜占庭容错（BFT）拜占庭式的容错(BFT)是一种被提议替代共识算法，用于更好的进行工作证明和验证算法。Ripple，Stellar，Hyperledger和Antshares等区块链技术项目正在调查BFT系统的版本。拜占庭式容错算法在未来可能日益重要，因为它们能够最大程度地减少节点故障和任意行为的攻击和软件错误。拜占庭协议通过参与分布式系统的一小部分节点来确保达成一致，尽管这是不合理的行为。一般来说，拜占庭协议制度的成员由中央机关或闭门谈判确定。值得注意的是，Ripple试图通过发布“starter”会员资格来分散BFT系统的招募，因此参与者可以自己编辑区块链。批评者抱怨说，这种设计最终会在系统维护人员的手中集中力量。(也就是负责招募的组织)麻省理工学院的研究人员认为，BFT整合了优化，“响应时间比之前的算法提高了一个数量级。”“拜占庭容错可以包含行为不正确的节点，并对其消息进行静音。BFT算法管理区块链节点之间的关系，使网络能够适应拜占庭将军的问题。当然，BFT系统很容易受到Sybil的攻击。现在已经有了几个使用这种共识方法的区块链平台。（IBM领导的超级账本项目提出PBFT方法 来源：金色财经）实用拜占庭容错（Practical Byzantine Fault Tolerance）超级账本是由IBM和Linux基金会领导的一项开源的区块链技术合作项目，实用拜占庭容错（PBFT）可能是其最著名的BFT变体。“实用的拜占庭式容错”被纳入了超级分类帐。超级账本结构提供了验证点（validating peers）的解决方案：智能合约（chaincode）表示事务；会员服务（membership services）；插件式一致性算法(Pluggable&Consensus)和其他方面。实用拜占庭容错的交易提供低延迟、高速文件存储解决方案和许多其他技术解决方案。（小蚁区块链推出dBFT共识机制 来源：金色财经）授权拜占庭容错（dBFT）小蚁区块链是一个分布式的智能合同平台，采用了拜占庭容错委托（dBFT）。它具有两个区块链接参与者：专业节点运算符，称为记账节点，通过运行节点赚钱，以及用户。支持者声称dBTF在区块链技术中提供更好的安全性。专门的记账节点“通过委托投票，在dBFT区块链中实现共识”。为了批准区块链的新版本，需要在节点之间通过三分之二的审批。支持者说，这个系统可以防止分叉事件的发生，对区块链系统的进行彻底的改革。“经过几年对加密货币和区块链技术的研究，我们得出结论，授权的拜占庭容错替代（或dBFT）最适合于这样一个系统，”小蚁区块链的联合创始人和核心开发人员Erik Iz说。“它提供了快速的事务验证时间，抑制了大多数恶意向量，并维护单个区块链版本，不会出现叉或替代区块链记录的风险，无论攻击者的计算能力多强或拥有多少硬币。（Stellar推出FBA协议 来源：金色财经）联邦拜占庭式协议（FBA）Stellar在其白皮书中介绍了联邦拜占庭协议（FBA）。与非联邦的拜占庭式协议一样，FBA解决了更新复制状态的问题，比如事务分类或证书树。该区块链技术白皮书中写道。“通过就应用的更新达成一致，避免了节点矛盾的、不可调和的状态。我们通过一个惟一的区块时段（Slot）来标识每个更新，从中可以推断出内部更新的依赖关系。例如，slot可能是连续编号的位置，在一个顺序应用的日志中。FBA系统运行一个一致协议，确保节点在slot内容上达成一致。”（Stellar推出FBA协议 来源：金色财经）该项目强调了好处:“当它安全地应用了所有依赖项的更新时，一个节点可以安全地在slot中应用更新，另外，它相信所有正确运行的节点最终都会同意slot的位置。在这一点上，我们说这个位置已经外化了。外部世界可能会以不可逆转的方式对外部化的值做出反应，因此一个节点不能在此后改变对它们的看法。研究人员说，恶意方可以多次加入FBA，并超过诚实的节点的数量。FBA拥有比其他共识方法更大的设置范围。
声明：本文系金色财经原创稿件，版权属金色财经所有，未经授权不得转载，已经协议授权的媒体下载使用时须注明&稿件来源：金色财经&，违者将依法追究责任。
您投送的稿件违反了金色财经的投稿协议，现已关闭您的投稿功能，如有异议请发邮件至进行申诉。工具显示源文件修订记录反向链接最近更改媒体管理器网站地图登录&
京东优惠券
python-files:dbf
Python 读取DBF/FPT 文件
DBF/FPT是 FoxPro 数据库存储文件的格式，虽然现在 FoxPro 已经不用了，但是有些情况下我们需要读取DBF/FPT数据库文件。这里整理了用Python读取DBF/FPT文件相关 Python 模块。
FPT 文件格式
FPT文件是FoxPro存储备注信息的文件。
The file format is used by Fox Pro 2.x and later The size of the header is 512 bytes
_______________________
0 | Number of next
1 | available block
2 | for appending data
3 | (binary)
|-----------------------|
4 | ( Reserved )
|-----------------------|
6 | Size of blocks N
|-----------------------|
8 | ( Reserved )
| (i.e. garbage)
|=======================| _v_____
Used block
|=======================|
0| Record type
|-----------------------|
|=======================| _|_____/
4| Length of memo field
|-----------------------|
8| Memo data
|=======================|
|=======================|
|=======================|
Big-endian. Binary value with high byte first.
Size of blocks in memo file (SET BLOCKSIZE). Default is 512 bytes.
Record type
Description
Picture. This normally indicates that file is produced on a MacIntosh, since pictures on the DOS/Windows platform are &objects&.
A memo field can be longer than the 512 byte block. It simply continues through the next block. The field is logically terminated by two End-of-file marks in the field. The reminder of the block is unused.
Python DBF模块
This is a DBF reader which reads Visual Fox Pro DBF format with Memo field.
rec = readDbf('test.dbf')
for line in rec:
print line['name']
@author Yusdi Santoso
@date 13/07/2007
import struct
import os, os.path
import sys
import csv
import tempfile
import ConfigParser
class Dbase:
def __init__(self):
self.fdb = None
self.fmemo = None
self.db_data = None
self.memo_data = None
self.fields = None
self.num_records = 0
self.header = None
self.memo_file = ''
self.memo_header = None
self.memo_block_size = 0
self.memo_header_len = 0
def _drop_after_NULL(self, txt):
for i in range(0, len(txt)):
if ord(struct.unpack('c', txt[i])[0])==0:
return txt[:i]
return txt
def _reverse_endian(self, num):
if not len(num):
val = struct.unpack('&L', num)
val = struct.pack('&L', val[0])
val = struct.unpack('&L', val)
return val[0]
def _assign_ids(self, lst, ids):
result = {}
for item in lst:
id = ids[idx]
result[id] = item
return result
def open(self, db_name):
filesize = os.path.getsize(db_name)
if filesize &= 68:
raise IOError, 'The file is not large enough to be a dbf file'
self.fdb = open(db_name, 'rb')
self.memo_file = ''
if os.path.isfile(db_name[0:-1] + 't'):
self.memo_file = db_name[0:-1] + 't'
elif os.path.isfile(db_name[0:-3] + 'fpt'):
self.memo_file = db_name[0:-3] + 'fpt'
if self.memo_file:
#Read memo file
self.fmemo = open(self.memo_file, 'rb')
self.memo_data = self.fmemo.read()
self.memo_header = self._assign_ids(struct.unpack('&6x1H', self.memo_data[:8]), ['Block size'])
block_size = self.memo_header['Block size']
if not block_size:
block_size = 512
self.memo_block_size = block_size
self.memo_header_len = block_size
memo_size = os.path.getsize(self.memo_file)
#Start reading data file
data = self.fdb.read(32)
self.header = self._assign_ids(struct.unpack('&B 3B L 2H 20x', data), ['id', 'Year', 'Month', 'Day', '# of Records', 'Header Size', 'Record Size'])
self.header['id'] = hex(self.header['id'])
self.num_records = self.header['# of Records']
data = self.fdb.read(self.header['Header Size']-34)
self.fields = {}
header_pattern = '&11s c 4x B B 14x'
ids = ['Field Name', 'Field Type', 'Field Length', 'Field Precision']
pattern_len = 32
for offset in range(0, len(data), 32):
if ord(data[offset])==0x0d:
data_subset = data[offset: offset+pattern_len]
if len(data_subset) & pattern_len:
data_subset += ' '*(pattern_len-len(data_subset))
self.fields[x] = self._assign_ids(struct.unpack(header_pattern, data_subset), ids)
self.fields[x]['Field Name'] = self._drop_after_NULL(self.fields[x]['Field Name'])
self.fdb.read(3)
if self.header['# of Records']:
data_size = (self.header['# of Records'] * self.header['Record Size']) - 1
self.db_data = self.fdb.read(data_size)
self.db_data = ''
self.row_format = '&'
self.row_ids = []
self.row_len = 0
for key in self.fields:
field = self.fields[key]
self.row_format += '%ds ' % (field['Field Length'])
self.row_ids.append(field['Field Name'])
self.row_len += field['Field Length']
def close(self):
if self.fdb:
self.fdb.close()
if self.fmemo:
self.fmemo.close()
def get_numrecords(self):
return self.num_records
def get_record_with_names(self, rec_no):
This function accept record number from 0 to N-1
if rec_no & 0 or rec_no & self.num_records:
raise Exception, 'Unable to extract data outside the range'
offset = self.header['Record Size'] * rec_no
data = self.db_data[offset:offset+self.row_len]
record = self._assign_ids(struct.unpack(self.row_format, data), self.row_ids)
if self.memo_file:
for key in self.fields:
field = self.fields[key]
f_type = field['Field Type']
f_name = field['Field Name']
c_data = record[f_name]
if f_type=='M' or f_type=='G' or f_type=='B' or f_type=='P':
c_data = self._reverse_endian(c_data)
if c_data:
record[f_name] = self.read_memo(c_data-1).strip()
record[f_name] = c_data.strip()
return record
def read_memo_record(self, num, in_length):
Read the record of given number. The second parameter is the length of
the record to read. It can be undefined, meaning read the whole record,
and it can be negative, meaning at most the length
if in_length & 0:
in_length = -self.memo_block_size
offset = self.memo_header_len + num * self.memo_block_size
self.fmemo.seek(offset)
if in_length&0:
in_length = -in_length
if in_length==0:
return self.fmemo.read(in_length)
def read_memo(self, num):
result = ''
buffer = self.read_memo_record(num, -1)
if len(buffer)&=0:
length = struct.unpack('&L', buffer[4:4+4])[0] + 8
block_size = self.memo_block_size
if length & block_size:
return buffer[8:length]
rest_length = length - block_size
rest_data = self.read_memo_record(num+1, rest_length)
if len(rest_data)&=0:
return buffer[8:] + rest_data
def readDbf(filename):
Read the DBF file specified by the filename and
return the records as a list of dictionary.
@param filename File name of the DBF
@return List of rows
db = Dbase()
db.open(filename)
num = db.get_numrecords()
rec = []
for i in range(0, num):
record = db.get_record_with_names(i)
rec.append(record)
db.close()
if __name__=='__main__':
rec = readDbf('dbf/sptable.dbf')
for line in rec:
print '%s %s' % (line['GENUS'].strip(), line['SPECIES'].strip())请问小蚁的共识算法dBFT基于怎样的考虑，作出了哪些改进？更为安全可控？ - 知乎49被浏览3516分享邀请回答0添加评论分享收藏感谢收起深交所跨市场ETF和本市场ETF的不同点--基金频道滚动新闻--人民网
深交所跨市场ETF和本市场ETF的不同点
&&&&&&&&&&&&&
跨市场ETF和本市场ETF的部分业务模式相同，主要的区别在于申购赎回处理的某些环节。
为便于在申购赎回时对跨市场ETF中的成份股进行现金替代，深交所新增虚拟成份股159900用于整体现金替代。对该虚拟成份股进行现金替代即相当于对所有成份股进行现金替代。为配合结算模式改造，我所在进行赎回的现金替代回报时，会将替代金额设置为0。为控制风险，我所根据基金管理公司需求对当日申购、赎回规模进行控制。若当日申购或者赎回总量超过限制，当日不再允许进行申购赎回。
对跨市场ETF申购赎回，T日（T为申购委托日）中国结算深圳分公司发送清算明细数据给相关结算参与人（通过SJSGF.DBF及SJSMX1.DBF接口），并发送汇总资金清算数据（通过SJSQS.DBF接口），T+1日发送资金交收结果（通过SJSGF.DBF和SJSJG.DBF接口）。【注：对赎回，结算接口中包括份额数据，不包括赎回资金】
因为赎回时涉及境内外资金的划转，并且境外交易所的交收周期和国内交易所未必一致，为了控制结算风险，中国结算深圳分公司对赎回资金实行非担保交收。基金公司负责对赎回资金进行清算，T+K日（T为赎回委托日，K由基金公司决定）中国结算深圳分公司接到基金公司指令后，转发明细赎回资金指令给券商（通过SJSGF.DBF及SJSMX2.DBF接口），同时体现在当日的资金清算数据（SJSQS.DBF）中，次结算日（T+K+1日）完成资金的代收代付，若应付方资金不足，则代收代付失败。这些失败的指令，基金公司可以以后再次发给中国结算深圳分公司进行代收代付，中国结算深圳分公司再次转发明细赎回资金指令给券商。具体可参见相关业务文档。