@taquito/local-forging
Version:
Local Tezos operation forging for Taquito.
541 lines (540 loc) • 21.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.burnLimitDecoder = exports.burnLimitEncoder = exports.entrypointNameDecoder = exports.entrypointNameEncoder = exports.blockPayloadHashDecoder = exports.blockPayloadHashEncoder = exports.valueParameterDecoder = exports.valueParameterEncoder = exports.parametersEncoder = exports.entrypointEncoder = exports.parametersDecoder = exports.entrypointDecoder = exports.zarithDecoder = exports.zarithEncoder = exports.smartRollupCommitmentHashDecoder = exports.smartContractAddressDecoder = exports.smartRollupAddressDecoder = exports.addressDecoder = exports.smartRollupCommitmentHashEncoder = exports.publicKeyDecoder = exports.smartContractAddressEncoder = exports.smartRollupAddressEncoder = exports.addressEncoder = exports.publicKeyEncoder = exports.publicKeyHashesEncoder = exports.publicKeyHashEncoder = exports.delegateDecoder = exports.boolDecoder = exports.int16Decoder = exports.int16Encoder = exports.int32Decoder = exports.int32Encoder = exports.delegateEncoder = exports.pvmKindDecoder = exports.pvmKindEncoder = exports.ballotDecoder = exports.ballotEncoder = exports.proposalsEncoder = exports.proposalsDecoder = exports.proposalDecoder = exports.proposalEncoder = exports.boolEncoder = exports.tz1Encoder = exports.branchEncoder = exports.publicKeyHashesDecoder = exports.publicKeyHashDecoder = exports.branchDecoder = exports.tz1Decoder = exports.prefixDecoder = exports.prefixEncoder = void 0;
exports.slotHeaderDecoder = exports.slotHeaderEncoder = exports.dalCommitmentDecoder = exports.dalCommitmentEncoder = exports.smartRollupMessageDecoder = exports.smartRollupMessageEncoder = exports.paddedBytesDecoder = exports.paddedBytesEncoder = exports.signatureProofDecoder = exports.signatureProofEncoder = exports.depositsLimitDecoder = exports.depositsLimitEncoder = void 0;
const utils_1 = require("@taquito/utils");
const errors_1 = require("./errors");
const bignumber_js_1 = require("bignumber.js");
const constants_1 = require("./constants");
const codec_1 = require("./michelson/codec");
const uint8array_consumer_1 = require("./uint8array-consumer");
const utils_2 = require("./utils");
const core_1 = require("@taquito/core");
// https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
const prefixEncoder = (prefix) => (str) => {
const [pl] = (0, utils_1.b58DecodeAndCheckPrefix)(str, [prefix]);
return (0, utils_1.buf2hex)(pl);
};
exports.prefixEncoder = prefixEncoder;
const prefixDecoder = (pre) => (str) => {
const val = str.consume(utils_1.payloadLength[pre]);
return (0, utils_1.b58Encode)(val, pre);
};
exports.prefixDecoder = prefixDecoder;
exports.tz1Decoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKeyHash);
exports.branchDecoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.BlockHash);
const publicKeyHashDecoder = (val) => {
const prefix = val.consume(1);
if (prefix[0] === 0x00) {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKeyHash)(val);
}
else if (prefix[0] === 0x01) {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.Secp256k1PublicKeyHash)(val);
}
else if (prefix[0] === 0x02) {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.P256PublicKeyHash)(val);
}
else if (prefix[0] === 0x03) {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381PublicKeyHash)(val);
}
};
exports.publicKeyHashDecoder = publicKeyHashDecoder;
const publicKeyHashesDecoder = (val) => {
if (!(0, exports.boolDecoder)(val)) {
return;
}
const publicKeyHashes = [];
val.consume(4);
while (val.length() > 0) {
publicKeyHashes.push((0, exports.publicKeyHashDecoder)(val));
}
return publicKeyHashes;
};
exports.publicKeyHashesDecoder = publicKeyHashesDecoder;
exports.branchEncoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.BlockHash);
exports.tz1Encoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.Ed25519PublicKeyHash);
const boolEncoder = (bool) => (bool ? 'ff' : '00');
exports.boolEncoder = boolEncoder;
const proposalEncoder = (proposal) => {
return (0, exports.prefixEncoder)(utils_1.PrefixV2.ProtocolHash)(proposal);
};
exports.proposalEncoder = proposalEncoder;
const proposalDecoder = (proposal) => {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.ProtocolHash)(proposal);
};
exports.proposalDecoder = proposalDecoder;
const proposalsDecoder = (proposal) => {
const proposals = [];
proposal.consume(4);
while (proposal.length() > 0) {
proposals.push((0, exports.proposalDecoder)(proposal));
}
return proposals;
};
exports.proposalsDecoder = proposalsDecoder;
const proposalsEncoder = (proposals) => {
return (0, utils_2.pad)(32 * proposals.length) + proposals.map((x) => (0, exports.proposalEncoder)(x)).join('');
};
exports.proposalsEncoder = proposalsEncoder;
const ballotEncoder = (ballot) => {
switch (ballot) {
case 'yay':
return '00';
case 'nay':
return '01';
case 'pass':
return '02';
default:
throw new errors_1.InvalidBallotValueError(ballot);
}
};
exports.ballotEncoder = ballotEncoder;
const ballotDecoder = (ballot) => {
const value = ballot.consume(1);
switch (value[0]) {
case 0x00:
return 'yay';
case 0x01:
return 'nay';
case 0x02:
return 'pass';
default:
throw new errors_1.DecodeBallotValueError(value[0].toString());
}
};
exports.ballotDecoder = ballotDecoder;
const pvmKindEncoder = (pvm) => {
switch (pvm) {
case 'arith':
return '00';
case 'wasm_2_0_0':
return '01';
case 'riscv':
return '02';
default:
throw new errors_1.UnsupportedPvmKindError(pvm);
}
};
exports.pvmKindEncoder = pvmKindEncoder;
const pvmKindDecoder = (pvm) => {
const value = pvm.consume(1);
switch (value[0]) {
case 0x00:
return 'arith';
case 0x01:
return 'wasm_2_0_0';
case 0x02:
return 'riscv';
default:
throw new errors_1.DecodePvmKindError(value[0].toString());
}
};
exports.pvmKindDecoder = pvmKindDecoder;
const delegateEncoder = (val) => {
if (val) {
return (0, exports.boolEncoder)(true) + (0, exports.publicKeyHashEncoder)(val);
}
else {
return (0, exports.boolEncoder)(false);
}
};
exports.delegateEncoder = delegateEncoder;
const int32Encoder = (val) => {
const num = parseInt(String(val), 10);
const byte = [];
for (let i = 0; i < 4; i++) {
const shiftBy = (4 - (i + 1)) * 8;
byte.push((num & (0xff << shiftBy)) >> shiftBy);
}
return Buffer.from(byte).toString('hex');
};
exports.int32Encoder = int32Encoder;
const int32Decoder = (val) => {
const num = val.consume(4);
let finalNum = 0;
for (let i = 0; i < num.length; i++) {
finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
}
return finalNum;
};
exports.int32Decoder = int32Decoder;
const int16Encoder = (val) => {
const num = parseInt(String(val), 10);
const byte = [];
for (let i = 0; i < 2; i++) {
const shiftBy = (2 - (i + 1)) * 8;
byte.push((num & (0xff << shiftBy)) >> shiftBy);
}
return Buffer.from(byte).toString('hex');
};
exports.int16Encoder = int16Encoder;
const int16Decoder = (val) => {
const num = val.consume(2);
let finalNum = 0;
for (let i = 0; i < num.length; i++) {
finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
}
return finalNum;
};
exports.int16Decoder = int16Decoder;
const boolDecoder = (val) => {
const bool = val.consume(1);
return bool[0] === 0xff;
};
exports.boolDecoder = boolDecoder;
const delegateDecoder = (val) => {
const hasDelegate = (0, exports.boolDecoder)(val);
if (hasDelegate) {
return (0, exports.publicKeyHashDecoder)(val);
}
};
exports.delegateDecoder = delegateDecoder;
const publicKeyHashEncoder = (val) => {
try {
return (0, utils_1.b58DecodePublicKeyHash)(val);
}
catch (err) {
throw new core_1.InvalidKeyHashError(val, err instanceof core_1.ParameterValidationError ? err.result : undefined);
}
};
exports.publicKeyHashEncoder = publicKeyHashEncoder;
const publicKeyHashesEncoder = (val) => {
if (!val) {
return (0, exports.boolEncoder)(false);
}
if (val.length === 0) {
return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(0);
}
const publicKeyHashes = val.reduce((prev, curr) => {
return prev + (0, exports.publicKeyHashEncoder)(curr);
}, '');
return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(publicKeyHashes.length / 2) + publicKeyHashes;
};
exports.publicKeyHashesEncoder = publicKeyHashesEncoder;
const publicKeyEncoder = (val) => {
try {
return (0, utils_1.b58DecodePublicKey)(val);
}
catch (err) {
throw new utils_1.InvalidPublicKeyError(val, err instanceof core_1.ParameterValidationError ? err.result : undefined);
}
};
exports.publicKeyEncoder = publicKeyEncoder;
const addressEncoder = (val) => {
return (0, utils_1.b58DecodeAddress)(val);
};
exports.addressEncoder = addressEncoder;
const smartRollupAddressEncoder = (val) => {
try {
return (0, exports.prefixEncoder)(utils_1.PrefixV2.SmartRollupHash)(val);
}
catch (err) {
if (err instanceof core_1.ParameterValidationError) {
throw new errors_1.InvalidSmartRollupAddressError(val);
}
else {
throw err;
}
}
};
exports.smartRollupAddressEncoder = smartRollupAddressEncoder;
const smartContractAddressEncoder = (val) => (0, utils_1.b58DecodeAddress)(val);
exports.smartContractAddressEncoder = smartContractAddressEncoder;
const publicKeyDecoder = (val) => {
const preamble = val.consume(1);
switch (preamble[0]) {
case 0x00:
return (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKey)(val);
case 0x01:
return (0, exports.prefixDecoder)(utils_1.PrefixV2.Secp256k1PublicKey)(val);
case 0x02:
return (0, exports.prefixDecoder)(utils_1.PrefixV2.P256PublicKey)(val);
case 0x03:
return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381PublicKey)(val);
default:
throw new utils_1.InvalidPublicKeyError(undefined, utils_1.ValidationResult.NO_PREFIX_MATCHED);
}
};
exports.publicKeyDecoder = publicKeyDecoder;
const smartRollupCommitmentHashEncoder = (val) => {
try {
return (0, exports.prefixEncoder)(utils_1.PrefixV2.SmartRollupCommitmentHash)(val);
}
catch (err) {
if (err instanceof core_1.ParameterValidationError) {
throw new errors_1.InvalidSmartRollupCommitmentHashError(val);
}
else {
throw err;
}
}
};
exports.smartRollupCommitmentHashEncoder = smartRollupCommitmentHashEncoder;
const addressDecoder = (val) => {
const preamble = val.consume(1);
switch (preamble[0]) {
case 0x00:
return (0, exports.publicKeyHashDecoder)(val);
case 0x01: {
const address = (0, exports.prefixDecoder)(utils_1.PrefixV2.ContractHash)(val);
val.consume(1);
return address;
}
default:
throw new core_1.InvalidAddressError(val.toString(), ': Unable to decode.');
}
};
exports.addressDecoder = addressDecoder;
const smartRollupAddressDecoder = (val) => {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.SmartRollupHash)(val);
};
exports.smartRollupAddressDecoder = smartRollupAddressDecoder;
const smartContractAddressDecoder = (val) => {
const preamble = val.consume(1);
if (preamble[0] === 0x01) {
const scAddress = (0, exports.prefixDecoder)(utils_1.PrefixV2.ContractHash)(val);
val.consume(1);
return scAddress;
}
throw new core_1.InvalidContractAddressError(val.toString(), utils_1.ValidationResult.NO_PREFIX_MATCHED);
};
exports.smartContractAddressDecoder = smartContractAddressDecoder;
const smartRollupCommitmentHashDecoder = (val) => {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.SmartRollupCommitmentHash)(val);
};
exports.smartRollupCommitmentHashDecoder = smartRollupCommitmentHashDecoder;
const zarithEncoder = (n) => {
const fn = [];
let nn = new bignumber_js_1.default(n, 10);
if (nn.isNaN()) {
throw new TypeError(`Invalid zarith number ${n}`);
}
// eslint-disable-next-line no-constant-condition
while (true) {
if (nn.lt(128)) {
if (nn.lt(16))
fn.push('0');
fn.push(nn.toString(16));
break;
}
else {
let b = nn.mod(128);
nn = nn.minus(b);
nn = nn.dividedBy(128);
b = b.plus(128);
fn.push(b.toString(16));
}
}
return fn.join('');
};
exports.zarithEncoder = zarithEncoder;
const zarithDecoder = (n) => {
let mostSignificantByte = 0;
while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
mostSignificantByte += 1;
}
let num = new bignumber_js_1.default(0);
for (let i = mostSignificantByte; i >= 0; i -= 1) {
const tmp = n.get(i) & 0x7f;
num = num.multipliedBy(128);
num = num.plus(tmp);
}
n.consume(mostSignificantByte + 1);
return new bignumber_js_1.default(num).toString();
};
exports.zarithDecoder = zarithDecoder;
const entrypointDecoder = (value) => {
const preamble = (0, utils_2.pad)(value.consume(1)[0], 2);
if (preamble in constants_1.entrypointMapping) {
return constants_1.entrypointMapping[preamble];
}
else {
const entry = (0, codec_1.extractRequiredLen)(value, 1);
const entrypoint = Buffer.from(entry).toString('utf8');
if (entrypoint.length > constants_1.ENTRYPOINT_MAX_LENGTH) {
throw new errors_1.OversizedEntryPointError(entrypoint);
}
return entrypoint;
}
};
exports.entrypointDecoder = entrypointDecoder;
const parametersDecoder = (val) => {
const preamble = val.consume(1);
if (preamble[0] === 0x00) {
return;
}
else {
const encodedEntrypoint = (0, exports.entrypointDecoder)(val);
const params = (0, codec_1.extractRequiredLen)(val);
const parameters = (0, codec_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(params));
return {
entrypoint: encodedEntrypoint,
value: parameters,
};
}
};
exports.parametersDecoder = parametersDecoder;
const entrypointEncoder = (entrypoint) => {
if (entrypoint in constants_1.entrypointMappingReverse) {
return `${constants_1.entrypointMappingReverse[entrypoint]}`;
}
else {
if (entrypoint.length > constants_1.ENTRYPOINT_MAX_LENGTH) {
throw new errors_1.OversizedEntryPointError(entrypoint);
}
const value = { string: entrypoint };
return `ff${(0, codec_1.valueEncoder)(value).slice(8)}`;
}
};
exports.entrypointEncoder = entrypointEncoder;
const parametersEncoder = (val) => {
if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
return '00';
}
const encodedEntrypoint = (0, exports.entrypointEncoder)(val.entrypoint);
const parameters = (0, codec_1.valueEncoder)(val.value);
const length = (0, utils_2.pad)(parameters.length / 2);
return `ff${encodedEntrypoint}${length}${parameters}`;
};
exports.parametersEncoder = parametersEncoder;
const valueParameterEncoder = (value) => {
const valueEncoded = (0, codec_1.valueEncoder)(value);
return `${(0, utils_2.pad)(valueEncoded.length / 2)}${valueEncoded}`;
};
exports.valueParameterEncoder = valueParameterEncoder;
const valueParameterDecoder = (val) => {
const value = (0, codec_1.extractRequiredLen)(val);
return (0, codec_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(value));
};
exports.valueParameterDecoder = valueParameterDecoder;
exports.blockPayloadHashEncoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.ValueHash);
exports.blockPayloadHashDecoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.ValueHash);
const entrypointNameEncoder = (entrypoint) => {
const value = { string: entrypoint };
return `${(0, codec_1.valueEncoder)(value).slice(2)}`;
};
exports.entrypointNameEncoder = entrypointNameEncoder;
const entrypointNameDecoder = (val) => {
const entry = (0, codec_1.extractRequiredLen)(val);
return Buffer.from(entry).toString('utf8');
};
exports.entrypointNameDecoder = entrypointNameDecoder;
const burnLimitEncoder = (val) => {
return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
};
exports.burnLimitEncoder = burnLimitEncoder;
const burnLimitDecoder = (value) => {
const prefix = value.consume(1);
if (Buffer.from(prefix).toString('hex') !== '00') {
return (0, exports.zarithDecoder)(value);
}
};
exports.burnLimitDecoder = burnLimitDecoder;
const depositsLimitEncoder = (val) => {
return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
};
exports.depositsLimitEncoder = depositsLimitEncoder;
const depositsLimitDecoder = (value) => {
const prefix = value.consume(1);
if (Buffer.from(prefix).toString('hex') !== '00') {
return (0, exports.zarithDecoder)(value);
}
};
exports.depositsLimitDecoder = depositsLimitDecoder;
const signatureV1Encoder = (val) => {
try {
const [data, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(val, utils_1.signaturePrefixes);
if (pre === utils_1.PrefixV2.BLS12_381Signature) {
return (0, exports.paddedBytesEncoder)((0, utils_1.buf2hex)(data));
}
else {
throw new core_1.ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
}
}
catch (err) {
if (err instanceof core_1.ParameterValidationError) {
throw new core_1.InvalidSignatureError(val, err.result);
}
else {
throw err;
}
}
};
const signatureV1Decoder = (val) => {
val.consume(4);
if (val.length().toString() === '96') {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381Signature)(val);
}
else {
throw new core_1.ProhibitedActionError('we only support decoding of BLSIG signatures');
}
};
const signatureProofEncoder = (val) => {
if (val) {
return (0, exports.boolEncoder)(true) + signatureV1Encoder(val);
}
else {
return (0, exports.boolEncoder)(false);
}
};
exports.signatureProofEncoder = signatureProofEncoder;
const signatureProofDecoder = (value) => {
const hasProof = (0, exports.boolDecoder)(value);
if (hasProof) {
return signatureV1Decoder(value);
}
};
exports.signatureProofDecoder = signatureProofDecoder;
const paddedBytesEncoder = (val, paddingLength = 8) => {
return `${(0, utils_2.pad)(val.length / 2, paddingLength)}${val}`;
};
exports.paddedBytesEncoder = paddedBytesEncoder;
const paddedBytesDecoder = (val) => {
const value = (0, codec_1.extractRequiredLen)(val);
return Buffer.from(value).toString('hex');
};
exports.paddedBytesDecoder = paddedBytesDecoder;
const smartRollupMessageEncoder = (val) => {
const message = val.reduce((prev, curr) => {
return prev + `${(0, utils_2.pad)(curr.length / 2)}${curr}`;
}, '');
return `${(0, utils_2.pad)(message.length / 2)}${message}`;
};
exports.smartRollupMessageEncoder = smartRollupMessageEncoder;
const smartRollupMessageDecoder = (val) => {
const valueArray = (0, codec_1.extractRequiredLen)(val);
const ret = (0, codec_1.stripLengthPrefixFromBytes)(new uint8array_consumer_1.Uint8ArrayConsumer(valueArray));
return ret.map((value) => Buffer.from(value).toString('hex'));
};
exports.smartRollupMessageDecoder = smartRollupMessageDecoder;
const dalCommitmentEncoder = (val) => {
try {
return (0, exports.prefixEncoder)(utils_1.PrefixV2.SlotHeader)(val);
}
catch (err) {
if (err instanceof core_1.ParameterValidationError) {
throw new errors_1.InvalidDalCommitmentError(val);
}
else {
throw err;
}
}
};
exports.dalCommitmentEncoder = dalCommitmentEncoder;
const dalCommitmentDecoder = (val) => {
return (0, exports.prefixDecoder)(utils_1.PrefixV2.SlotHeader)(val);
};
exports.dalCommitmentDecoder = dalCommitmentDecoder;
const slotHeaderEncoder = (val) => {
return (0, utils_2.pad)(val.slot_index, 2) + (0, exports.dalCommitmentEncoder)(val.commitment) + val.commitment_proof;
};
exports.slotHeaderEncoder = slotHeaderEncoder;
const slotHeaderDecoder = (val) => {
const preamble = val.consume(1);
return {
slot_index: Number(preamble[0].toString(10)),
commitment: (0, exports.dalCommitmentDecoder)(val),
commitment_proof: (0, utils_2.toHexString)(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
};
};
exports.slotHeaderDecoder = slotHeaderDecoder;