@waves/protobuf-serialization
Version:
Generated types and methods for encoding and decoding protobuf messages as well as working with gRPC services.
1,088 lines (989 loc) • 340 kB
JavaScript
/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
"use strict";
var $protobuf = require("protobufjs/minimal");
var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
$root.waves = (function() {
var waves = {};
waves.Amount = (function() {
function Amount(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
Amount.prototype.assetId = $util.newBuffer([]);
Amount.prototype.amount = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
Amount.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.assetId != null && m.hasOwnProperty("assetId"))
w.uint32(10).bytes(m.assetId);
if (m.amount != null && m.hasOwnProperty("amount"))
w.uint32(16).int64(m.amount);
return w;
};
Amount.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.Amount();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.assetId = r.bytes();
break;
case 2:
m.amount = r.int64();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return Amount;
})();
waves.Block = (function() {
function Block(p) {
this.transactions = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
Block.prototype.header = null;
Block.prototype.signature = $util.newBuffer([]);
Block.prototype.transactions = $util.emptyArray;
Block.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.header != null && m.hasOwnProperty("header"))
$root.waves.Block.Header.encode(m.header, w.uint32(10).fork()).ldelim();
if (m.signature != null && m.hasOwnProperty("signature"))
w.uint32(18).bytes(m.signature);
if (m.transactions != null && m.transactions.length) {
for (var i = 0; i < m.transactions.length; ++i)
$root.waves.SignedTransaction.encode(m.transactions[i], w.uint32(26).fork()).ldelim();
}
return w;
};
Block.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.Block();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.header = $root.waves.Block.Header.decode(r, r.uint32());
break;
case 2:
m.signature = r.bytes();
break;
case 3:
if (!(m.transactions && m.transactions.length))
m.transactions = [];
m.transactions.push($root.waves.SignedTransaction.decode(r, r.uint32()));
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
Block.Header = (function() {
function Header(p) {
this.featureVotes = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
Header.prototype.chainId = 0;
Header.prototype.reference = $util.newBuffer([]);
Header.prototype.baseTarget = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
Header.prototype.generationSignature = $util.newBuffer([]);
Header.prototype.featureVotes = $util.emptyArray;
Header.prototype.timestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
Header.prototype.version = 0;
Header.prototype.generator = $util.newBuffer([]);
Header.prototype.rewardVote = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
Header.prototype.transactionsRoot = $util.newBuffer([]);
Header.prototype.stateHash = $util.newBuffer([]);
Header.prototype.challengedHeader = null;
Header.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.chainId != null && m.hasOwnProperty("chainId"))
w.uint32(8).int32(m.chainId);
if (m.reference != null && m.hasOwnProperty("reference"))
w.uint32(18).bytes(m.reference);
if (m.baseTarget != null && m.hasOwnProperty("baseTarget"))
w.uint32(24).int64(m.baseTarget);
if (m.generationSignature != null && m.hasOwnProperty("generationSignature"))
w.uint32(34).bytes(m.generationSignature);
if (m.featureVotes != null && m.featureVotes.length) {
w.uint32(42).fork();
for (var i = 0; i < m.featureVotes.length; ++i)
w.uint32(m.featureVotes[i]);
w.ldelim();
}
if (m.timestamp != null && m.hasOwnProperty("timestamp"))
w.uint32(48).int64(m.timestamp);
if (m.version != null && m.hasOwnProperty("version"))
w.uint32(56).int32(m.version);
if (m.generator != null && m.hasOwnProperty("generator"))
w.uint32(66).bytes(m.generator);
if (m.rewardVote != null && m.hasOwnProperty("rewardVote"))
w.uint32(72).int64(m.rewardVote);
if (m.transactionsRoot != null && m.hasOwnProperty("transactionsRoot"))
w.uint32(82).bytes(m.transactionsRoot);
if (m.stateHash != null && m.hasOwnProperty("stateHash"))
w.uint32(90).bytes(m.stateHash);
if (m.challengedHeader != null && m.hasOwnProperty("challengedHeader"))
$root.waves.Block.Header.ChallengedHeader.encode(m.challengedHeader, w.uint32(98).fork()).ldelim();
return w;
};
Header.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.Block.Header();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.chainId = r.int32();
break;
case 2:
m.reference = r.bytes();
break;
case 3:
m.baseTarget = r.int64();
break;
case 4:
m.generationSignature = r.bytes();
break;
case 5:
if (!(m.featureVotes && m.featureVotes.length))
m.featureVotes = [];
if ((t & 7) === 2) {
var c2 = r.uint32() + r.pos;
while (r.pos < c2)
m.featureVotes.push(r.uint32());
} else
m.featureVotes.push(r.uint32());
break;
case 6:
m.timestamp = r.int64();
break;
case 7:
m.version = r.int32();
break;
case 8:
m.generator = r.bytes();
break;
case 9:
m.rewardVote = r.int64();
break;
case 10:
m.transactionsRoot = r.bytes();
break;
case 11:
m.stateHash = r.bytes();
break;
case 12:
m.challengedHeader = $root.waves.Block.Header.ChallengedHeader.decode(r, r.uint32());
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
Header.ChallengedHeader = (function() {
function ChallengedHeader(p) {
this.featureVotes = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
ChallengedHeader.prototype.baseTarget = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
ChallengedHeader.prototype.generationSignature = $util.newBuffer([]);
ChallengedHeader.prototype.featureVotes = $util.emptyArray;
ChallengedHeader.prototype.timestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
ChallengedHeader.prototype.generator = $util.newBuffer([]);
ChallengedHeader.prototype.rewardVote = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
ChallengedHeader.prototype.stateHash = $util.newBuffer([]);
ChallengedHeader.prototype.headerSignature = $util.newBuffer([]);
ChallengedHeader.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.baseTarget != null && m.hasOwnProperty("baseTarget"))
w.uint32(8).int64(m.baseTarget);
if (m.generationSignature != null && m.hasOwnProperty("generationSignature"))
w.uint32(18).bytes(m.generationSignature);
if (m.featureVotes != null && m.featureVotes.length) {
w.uint32(26).fork();
for (var i = 0; i < m.featureVotes.length; ++i)
w.uint32(m.featureVotes[i]);
w.ldelim();
}
if (m.timestamp != null && m.hasOwnProperty("timestamp"))
w.uint32(32).int64(m.timestamp);
if (m.generator != null && m.hasOwnProperty("generator"))
w.uint32(42).bytes(m.generator);
if (m.rewardVote != null && m.hasOwnProperty("rewardVote"))
w.uint32(48).int64(m.rewardVote);
if (m.stateHash != null && m.hasOwnProperty("stateHash"))
w.uint32(58).bytes(m.stateHash);
if (m.headerSignature != null && m.hasOwnProperty("headerSignature"))
w.uint32(66).bytes(m.headerSignature);
return w;
};
ChallengedHeader.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.Block.Header.ChallengedHeader();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.baseTarget = r.int64();
break;
case 2:
m.generationSignature = r.bytes();
break;
case 3:
if (!(m.featureVotes && m.featureVotes.length))
m.featureVotes = [];
if ((t & 7) === 2) {
var c2 = r.uint32() + r.pos;
while (r.pos < c2)
m.featureVotes.push(r.uint32());
} else
m.featureVotes.push(r.uint32());
break;
case 4:
m.timestamp = r.int64();
break;
case 5:
m.generator = r.bytes();
break;
case 6:
m.rewardVote = r.int64();
break;
case 7:
m.stateHash = r.bytes();
break;
case 8:
m.headerSignature = r.bytes();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return ChallengedHeader;
})();
return Header;
})();
return Block;
})();
waves.MicroBlock = (function() {
function MicroBlock(p) {
this.transactions = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
MicroBlock.prototype.version = 0;
MicroBlock.prototype.reference = $util.newBuffer([]);
MicroBlock.prototype.updatedBlockSignature = $util.newBuffer([]);
MicroBlock.prototype.senderPublicKey = $util.newBuffer([]);
MicroBlock.prototype.transactions = $util.emptyArray;
MicroBlock.prototype.stateHash = $util.newBuffer([]);
MicroBlock.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.version != null && m.hasOwnProperty("version"))
w.uint32(8).int32(m.version);
if (m.reference != null && m.hasOwnProperty("reference"))
w.uint32(18).bytes(m.reference);
if (m.updatedBlockSignature != null && m.hasOwnProperty("updatedBlockSignature"))
w.uint32(26).bytes(m.updatedBlockSignature);
if (m.senderPublicKey != null && m.hasOwnProperty("senderPublicKey"))
w.uint32(34).bytes(m.senderPublicKey);
if (m.transactions != null && m.transactions.length) {
for (var i = 0; i < m.transactions.length; ++i)
$root.waves.SignedTransaction.encode(m.transactions[i], w.uint32(42).fork()).ldelim();
}
if (m.stateHash != null && m.hasOwnProperty("stateHash"))
w.uint32(50).bytes(m.stateHash);
return w;
};
MicroBlock.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.MicroBlock();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.version = r.int32();
break;
case 2:
m.reference = r.bytes();
break;
case 3:
m.updatedBlockSignature = r.bytes();
break;
case 4:
m.senderPublicKey = r.bytes();
break;
case 5:
if (!(m.transactions && m.transactions.length))
m.transactions = [];
m.transactions.push($root.waves.SignedTransaction.decode(r, r.uint32()));
break;
case 6:
m.stateHash = r.bytes();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return MicroBlock;
})();
waves.SignedMicroBlock = (function() {
function SignedMicroBlock(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
SignedMicroBlock.prototype.microBlock = null;
SignedMicroBlock.prototype.signature = $util.newBuffer([]);
SignedMicroBlock.prototype.totalBlockId = $util.newBuffer([]);
SignedMicroBlock.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.microBlock != null && m.hasOwnProperty("microBlock"))
$root.waves.MicroBlock.encode(m.microBlock, w.uint32(10).fork()).ldelim();
if (m.signature != null && m.hasOwnProperty("signature"))
w.uint32(18).bytes(m.signature);
if (m.totalBlockId != null && m.hasOwnProperty("totalBlockId"))
w.uint32(26).bytes(m.totalBlockId);
return w;
};
SignedMicroBlock.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.SignedMicroBlock();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.microBlock = $root.waves.MicroBlock.decode(r, r.uint32());
break;
case 2:
m.signature = r.bytes();
break;
case 3:
m.totalBlockId = r.bytes();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return SignedMicroBlock;
})();
waves.events = (function() {
var events = {};
events.BlockchainUpdated = (function() {
function BlockchainUpdated(p) {
this.referencedAssets = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
BlockchainUpdated.prototype.id = $util.newBuffer([]);
BlockchainUpdated.prototype.height = 0;
BlockchainUpdated.prototype.append = null;
BlockchainUpdated.prototype.rollback = null;
BlockchainUpdated.prototype.referencedAssets = $util.emptyArray;
var $oneOfFields;
Object.defineProperty(BlockchainUpdated.prototype, "update", {
get: $util.oneOfGetter($oneOfFields = ["append", "rollback"]),
set: $util.oneOfSetter($oneOfFields)
});
BlockchainUpdated.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.id != null && m.hasOwnProperty("id"))
w.uint32(10).bytes(m.id);
if (m.height != null && m.hasOwnProperty("height"))
w.uint32(16).int32(m.height);
if (m.append != null && m.hasOwnProperty("append"))
$root.waves.events.BlockchainUpdated.Append.encode(m.append, w.uint32(90).fork()).ldelim();
if (m.rollback != null && m.hasOwnProperty("rollback"))
$root.waves.events.BlockchainUpdated.Rollback.encode(m.rollback, w.uint32(98).fork()).ldelim();
if (m.referencedAssets != null && m.referencedAssets.length) {
for (var i = 0; i < m.referencedAssets.length; ++i)
$root.waves.events.StateUpdate.AssetInfo.encode(m.referencedAssets[i], w.uint32(170).fork()).ldelim();
}
return w;
};
BlockchainUpdated.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.BlockchainUpdated();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.id = r.bytes();
break;
case 2:
m.height = r.int32();
break;
case 11:
m.append = $root.waves.events.BlockchainUpdated.Append.decode(r, r.uint32());
break;
case 12:
m.rollback = $root.waves.events.BlockchainUpdated.Rollback.decode(r, r.uint32());
break;
case 21:
if (!(m.referencedAssets && m.referencedAssets.length))
m.referencedAssets = [];
m.referencedAssets.push($root.waves.events.StateUpdate.AssetInfo.decode(r, r.uint32()));
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
BlockchainUpdated.Append = (function() {
function Append(p) {
this.transactionIds = [];
this.transactionsMetadata = [];
this.transactionStateUpdates = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
Append.prototype.block = null;
Append.prototype.microBlock = null;
Append.prototype.transactionIds = $util.emptyArray;
Append.prototype.transactionsMetadata = $util.emptyArray;
Append.prototype.stateUpdate = null;
Append.prototype.transactionStateUpdates = $util.emptyArray;
var $oneOfFields;
Object.defineProperty(Append.prototype, "body", {
get: $util.oneOfGetter($oneOfFields = ["block", "microBlock"]),
set: $util.oneOfSetter($oneOfFields)
});
Append.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.block != null && m.hasOwnProperty("block"))
$root.waves.events.BlockchainUpdated.Append.BlockAppend.encode(m.block, w.uint32(10).fork()).ldelim();
if (m.microBlock != null && m.hasOwnProperty("microBlock"))
$root.waves.events.BlockchainUpdated.Append.MicroBlockAppend.encode(m.microBlock, w.uint32(18).fork()).ldelim();
if (m.transactionIds != null && m.transactionIds.length) {
for (var i = 0; i < m.transactionIds.length; ++i)
w.uint32(26).bytes(m.transactionIds[i]);
}
if (m.transactionsMetadata != null && m.transactionsMetadata.length) {
for (var i = 0; i < m.transactionsMetadata.length; ++i)
$root.waves.events.TransactionMetadata.encode(m.transactionsMetadata[i], w.uint32(34).fork()).ldelim();
}
if (m.stateUpdate != null && m.hasOwnProperty("stateUpdate"))
$root.waves.events.StateUpdate.encode(m.stateUpdate, w.uint32(90).fork()).ldelim();
if (m.transactionStateUpdates != null && m.transactionStateUpdates.length) {
for (var i = 0; i < m.transactionStateUpdates.length; ++i)
$root.waves.events.StateUpdate.encode(m.transactionStateUpdates[i], w.uint32(98).fork()).ldelim();
}
return w;
};
Append.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.BlockchainUpdated.Append();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.block = $root.waves.events.BlockchainUpdated.Append.BlockAppend.decode(r, r.uint32());
break;
case 2:
m.microBlock = $root.waves.events.BlockchainUpdated.Append.MicroBlockAppend.decode(r, r.uint32());
break;
case 3:
if (!(m.transactionIds && m.transactionIds.length))
m.transactionIds = [];
m.transactionIds.push(r.bytes());
break;
case 4:
if (!(m.transactionsMetadata && m.transactionsMetadata.length))
m.transactionsMetadata = [];
m.transactionsMetadata.push($root.waves.events.TransactionMetadata.decode(r, r.uint32()));
break;
case 11:
m.stateUpdate = $root.waves.events.StateUpdate.decode(r, r.uint32());
break;
case 12:
if (!(m.transactionStateUpdates && m.transactionStateUpdates.length))
m.transactionStateUpdates = [];
m.transactionStateUpdates.push($root.waves.events.StateUpdate.decode(r, r.uint32()));
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
Append.BlockAppend = (function() {
function BlockAppend(p) {
this.activatedFeatures = [];
this.rewardShares = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
BlockAppend.prototype.block = null;
BlockAppend.prototype.updatedWavesAmount = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
BlockAppend.prototype.activatedFeatures = $util.emptyArray;
BlockAppend.prototype.vrf = $util.newBuffer([]);
BlockAppend.prototype.rewardShares = $util.emptyArray;
BlockAppend.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.block != null && m.hasOwnProperty("block"))
$root.waves.Block.encode(m.block, w.uint32(10).fork()).ldelim();
if (m.updatedWavesAmount != null && m.hasOwnProperty("updatedWavesAmount"))
w.uint32(16).int64(m.updatedWavesAmount);
if (m.activatedFeatures != null && m.activatedFeatures.length) {
w.uint32(26).fork();
for (var i = 0; i < m.activatedFeatures.length; ++i)
w.int32(m.activatedFeatures[i]);
w.ldelim();
}
if (m.vrf != null && m.hasOwnProperty("vrf"))
w.uint32(34).bytes(m.vrf);
if (m.rewardShares != null && m.rewardShares.length) {
for (var i = 0; i < m.rewardShares.length; ++i)
$root.waves.RewardShare.encode(m.rewardShares[i], w.uint32(42).fork()).ldelim();
}
return w;
};
BlockAppend.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.BlockchainUpdated.Append.BlockAppend();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.block = $root.waves.Block.decode(r, r.uint32());
break;
case 2:
m.updatedWavesAmount = r.int64();
break;
case 3:
if (!(m.activatedFeatures && m.activatedFeatures.length))
m.activatedFeatures = [];
if ((t & 7) === 2) {
var c2 = r.uint32() + r.pos;
while (r.pos < c2)
m.activatedFeatures.push(r.int32());
} else
m.activatedFeatures.push(r.int32());
break;
case 4:
m.vrf = r.bytes();
break;
case 5:
if (!(m.rewardShares && m.rewardShares.length))
m.rewardShares = [];
m.rewardShares.push($root.waves.RewardShare.decode(r, r.uint32()));
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return BlockAppend;
})();
Append.MicroBlockAppend = (function() {
function MicroBlockAppend(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
MicroBlockAppend.prototype.microBlock = null;
MicroBlockAppend.prototype.updatedTransactionsRoot = $util.newBuffer([]);
MicroBlockAppend.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.microBlock != null && m.hasOwnProperty("microBlock"))
$root.waves.SignedMicroBlock.encode(m.microBlock, w.uint32(10).fork()).ldelim();
if (m.updatedTransactionsRoot != null && m.hasOwnProperty("updatedTransactionsRoot"))
w.uint32(18).bytes(m.updatedTransactionsRoot);
return w;
};
MicroBlockAppend.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.BlockchainUpdated.Append.MicroBlockAppend();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.microBlock = $root.waves.SignedMicroBlock.decode(r, r.uint32());
break;
case 2:
m.updatedTransactionsRoot = r.bytes();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return MicroBlockAppend;
})();
return Append;
})();
BlockchainUpdated.Rollback = (function() {
function Rollback(p) {
this.removedTransactionIds = [];
this.removedBlocks = [];
this.deactivatedFeatures = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
Rollback.prototype.type = 0;
Rollback.prototype.removedTransactionIds = $util.emptyArray;
Rollback.prototype.removedBlocks = $util.emptyArray;
Rollback.prototype.rollbackStateUpdate = null;
Rollback.prototype.deactivatedFeatures = $util.emptyArray;
Rollback.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.type != null && m.hasOwnProperty("type"))
w.uint32(8).int32(m.type);
if (m.removedTransactionIds != null && m.removedTransactionIds.length) {
for (var i = 0; i < m.removedTransactionIds.length; ++i)
w.uint32(18).bytes(m.removedTransactionIds[i]);
}
if (m.removedBlocks != null && m.removedBlocks.length) {
for (var i = 0; i < m.removedBlocks.length; ++i)
$root.waves.Block.encode(m.removedBlocks[i], w.uint32(26).fork()).ldelim();
}
if (m.rollbackStateUpdate != null && m.hasOwnProperty("rollbackStateUpdate"))
$root.waves.events.StateUpdate.encode(m.rollbackStateUpdate, w.uint32(34).fork()).ldelim();
if (m.deactivatedFeatures != null && m.deactivatedFeatures.length) {
w.uint32(42).fork();
for (var i = 0; i < m.deactivatedFeatures.length; ++i)
w.int32(m.deactivatedFeatures[i]);
w.ldelim();
}
return w;
};
Rollback.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.BlockchainUpdated.Rollback();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.type = r.int32();
break;
case 2:
if (!(m.removedTransactionIds && m.removedTransactionIds.length))
m.removedTransactionIds = [];
m.removedTransactionIds.push(r.bytes());
break;
case 3:
if (!(m.removedBlocks && m.removedBlocks.length))
m.removedBlocks = [];
m.removedBlocks.push($root.waves.Block.decode(r, r.uint32()));
break;
case 4:
m.rollbackStateUpdate = $root.waves.events.StateUpdate.decode(r, r.uint32());
break;
case 5:
if (!(m.deactivatedFeatures && m.deactivatedFeatures.length))
m.deactivatedFeatures = [];
if ((t & 7) === 2) {
var c2 = r.uint32() + r.pos;
while (r.pos < c2)
m.deactivatedFeatures.push(r.int32());
} else
m.deactivatedFeatures.push(r.int32());
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
Rollback.RollbackType = (function() {
var valuesById = {}, values = Object.create(valuesById);
values[valuesById[0] = "BLOCK"] = 0;
values[valuesById[1] = "MICROBLOCK"] = 1;
return values;
})();
return Rollback;
})();
return BlockchainUpdated;
})();
events.StateUpdate = (function() {
function StateUpdate(p) {
this.balances = [];
this.leasingForAddress = [];
this.dataEntries = [];
this.assets = [];
this.individualLeases = [];
this.scripts = [];
this.deletedAliases = [];
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
StateUpdate.prototype.balances = $util.emptyArray;
StateUpdate.prototype.leasingForAddress = $util.emptyArray;
StateUpdate.prototype.dataEntries = $util.emptyArray;
StateUpdate.prototype.assets = $util.emptyArray;
StateUpdate.prototype.individualLeases = $util.emptyArray;
StateUpdate.prototype.scripts = $util.emptyArray;
StateUpdate.prototype.deletedAliases = $util.emptyArray;
StateUpdate.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.balances != null && m.balances.length) {
for (var i = 0; i < m.balances.length; ++i)
$root.waves.events.StateUpdate.BalanceUpdate.encode(m.balances[i], w.uint32(10).fork()).ldelim();
}
if (m.leasingForAddress != null && m.leasingForAddress.length) {
for (var i = 0; i < m.leasingForAddress.length; ++i)
$root.waves.events.StateUpdate.LeasingUpdate.encode(m.leasingForAddress[i], w.uint32(18).fork()).ldelim();
}
if (m.dataEntries != null && m.dataEntries.length) {
for (var i = 0; i < m.dataEntries.length; ++i)
$root.waves.events.StateUpdate.DataEntryUpdate.encode(m.dataEntries[i], w.uint32(26).fork()).ldelim();
}
if (m.assets != null && m.assets.length) {
for (var i = 0; i < m.assets.length; ++i)
$root.waves.events.StateUpdate.AssetStateUpdate.encode(m.assets[i], w.uint32(34).fork()).ldelim();
}
if (m.individualLeases != null && m.individualLeases.length) {
for (var i = 0; i < m.individualLeases.length; ++i)
$root.waves.events.StateUpdate.LeaseUpdate.encode(m.individualLeases[i], w.uint32(42).fork()).ldelim();
}
if (m.scripts != null && m.scripts.length) {
for (var i = 0; i < m.scripts.length; ++i)
$root.waves.events.StateUpdate.ScriptUpdate.encode(m.scripts[i], w.uint32(50).fork()).ldelim();
}
if (m.deletedAliases != null && m.deletedAliases.length) {
for (var i = 0; i < m.deletedAliases.length; ++i)
w.uint32(58).string(m.deletedAliases[i]);
}
return w;
};
StateUpdate.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.StateUpdate();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
if (!(m.balances && m.balances.length))
m.balances = [];
m.balances.push($root.waves.events.StateUpdate.BalanceUpdate.decode(r, r.uint32()));
break;
case 2:
if (!(m.leasingForAddress && m.leasingForAddress.length))
m.leasingForAddress = [];
m.leasingForAddress.push($root.waves.events.StateUpdate.LeasingUpdate.decode(r, r.uint32()));
break;
case 3:
if (!(m.dataEntries && m.dataEntries.length))
m.dataEntries = [];
m.dataEntries.push($root.waves.events.StateUpdate.DataEntryUpdate.decode(r, r.uint32()));
break;
case 4:
if (!(m.assets && m.assets.length))
m.assets = [];
m.assets.push($root.waves.events.StateUpdate.AssetStateUpdate.decode(r, r.uint32()));
break;
case 5:
if (!(m.individualLeases && m.individualLeases.length))
m.individualLeases = [];
m.individualLeases.push($root.waves.events.StateUpdate.LeaseUpdate.decode(r, r.uint32()));
break;
case 6:
if (!(m.scripts && m.scripts.length))
m.scripts = [];
m.scripts.push($root.waves.events.StateUpdate.ScriptUpdate.decode(r, r.uint32()));
break;
case 7:
if (!(m.deletedAliases && m.deletedAliases.length))
m.deletedAliases = [];
m.deletedAliases.push(r.string());
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
StateUpdate.BalanceUpdate = (function() {
function BalanceUpdate(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
BalanceUpdate.prototype.address = $util.newBuffer([]);
BalanceUpdate.prototype.amountAfter = null;
BalanceUpdate.prototype.amountBefore = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
BalanceUpdate.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.address != null && m.hasOwnProperty("address"))
w.uint32(10).bytes(m.address);
if (m.amountAfter != null && m.hasOwnProperty("amountAfter"))
$root.waves.Amount.encode(m.amountAfter, w.uint32(18).fork()).ldelim();
if (m.amountBefore != null && m.hasOwnProperty("amountBefore"))
w.uint32(24).int64(m.amountBefore);
return w;
};
BalanceUpdate.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.StateUpdate.BalanceUpdate();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.address = r.bytes();
break;
case 2:
m.amountAfter = $root.waves.Amount.decode(r, r.uint32());
break;
case 3:
m.amountBefore = r.int64();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return BalanceUpdate;
})();
StateUpdate.LeasingUpdate = (function() {
function LeasingUpdate(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
LeasingUpdate.prototype.address = $util.newBuffer([]);
LeasingUpdate.prototype.inAfter = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
LeasingUpdate.prototype.outAfter = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
LeasingUpdate.prototype.inBefore = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
LeasingUpdate.prototype.outBefore = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
LeasingUpdate.encode = function encode(m, w) {
if (!w)
w = $Writer.create();
if (m.address != null && m.hasOwnProperty("address"))
w.uint32(10).bytes(m.address);
if (m.inAfter != null && m.hasOwnProperty("inAfter"))
w.uint32(16).int64(m.inAfter);
if (m.outAfter != null && m.hasOwnProperty("outAfter"))
w.uint32(24).int64(m.outAfter);
if (m.inBefore != null && m.hasOwnProperty("inBefore"))
w.uint32(32).int64(m.inBefore);
if (m.outBefore != null && m.hasOwnProperty("outBefore"))
w.uint32(40).int64(m.outBefore);
return w;
};
LeasingUpdate.decode = function decode(r, l) {
if (!(r instanceof $Reader))
r = $Reader.create(r);
var c = l === undefined ? r.len : r.pos + l, m = new $root.waves.events.StateUpdate.LeasingUpdate();
while (r.pos < c) {
var t = r.uint32();
switch (t >>> 3) {
case 1:
m.address = r.bytes();
break;
case 2:
m.inAfter = r.int64();
break;
case 3:
m.outAfter = r.int64();
break;
case 4:
m.inBefore = r.int64();
break;
case 5:
m.outBefore = r.int64();
break;
default:
r.skipType(t & 7);
break;
}
}
return m;
};
return LeasingUpdate;
})();
StateUpdate.LeaseUpdate = (function() {
function LeaseUpdate(p) {
if (p)
for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
if (p[ks[i]] != null)
this[ks[i]] = p[ks[i]];
}
LeaseUpdate.prototype.leaseId = $util.newBuffer([]);
LeaseUpdate.prototype.statusAfter = 0;
LeaseUpdate.prototype.amount = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
LeaseUpdate.prototype.sender = $util.newBuffer([]);
LeaseUpdate.prototype.recipient = $util.newBuffer([]);
LeaseUpdate.prototype.originTransactionId = $util.newBuffer([]);
Le