@stricahq/typhonjs
Version:
Pure JS Cardano Wallet library
865 lines (864 loc) • 37.7 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.encodeProposalProcedures = exports.encodeProtocolParamUpdate = exports.encodeVotingProcedures = exports.encodeNativeScript = exports.encodeLanguageViews = exports.encodePlutusData = exports.encodeAuxiliaryData = exports.encodeMetadata = exports.encodeWitnesses = exports.encodeVKeyWitness = exports.encodeCertificates = exports.encodeDRepUpdateCertificate = exports.encodeDRepDeRegCertificate = exports.encodeDRepRegCertificate = exports.encodeCommitteeResignColdCertificate = exports.encodeCommitteeAuthHotCertificate = exports.encodeStakeVoteRegDelegationCertificate = exports.encodeVoteRegDelegationCertificate = exports.encodeStakeRegDelegationCertificate = exports.encodeStakeVoteDelegationCertificate = exports.encodeVoteDelegationCertificate = exports.encodeStakeKeyDeRegistrationCertificate = exports.encodeStakeKeyRegistrationCertificate = exports.encodeStakeDelegationCertificate = exports.encodeStakeDeRegistrationCertificate = exports.encodeStakeRegistrationCertificate = exports.encodeCredential = exports.encodeAnchor = exports.encodeDRep = exports.encodeWithdrawals = exports.encodeOutputs = exports.encodeOutput = exports.encodeMint = exports.encodeOutputTokens = exports.encodeCollaterals = exports.encodeInputs = void 0;
/* eslint-disable @typescript-eslint/no-use-before-define */
/* eslint-disable no-use-before-define */
const buffer_1 = require("buffer");
const cbors = __importStar(require("@stricahq/cbors"));
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const lodash_1 = __importDefault(require("lodash"));
const types_1 = require("../types");
const helpers_1 = require("./helpers");
const crypto_1 = require("./crypto");
const internal_types_1 = require("../internal-types");
const encodeInputs = (inputs) => {
const encodedInputs = inputs.map((input) => {
const txHash = buffer_1.Buffer.from(input.txId, "hex");
return [txHash, input.index];
});
return encodedInputs;
};
exports.encodeInputs = encodeInputs;
const encodeCollaterals = (collaterals) => {
const encodedCollateralInputs = collaterals.map((collateral) => {
const txHash = buffer_1.Buffer.from(collateral.txId, "hex");
return [txHash, collateral.index];
});
return encodedCollateralInputs;
};
exports.encodeCollaterals = encodeCollaterals;
const encodeOutputTokens = (tokens) => {
const policyIdMap = new Map();
const tokenBundle = (0, lodash_1.default)(tokens)
.groupBy(({ policyId }) => policyId)
.value();
lodash_1.default.forEach(tokenBundle, (token, policyId) => {
const tokenMap = new Map();
token.forEach(({ assetName, amount }) => {
tokenMap.set(buffer_1.Buffer.from(assetName, "hex"), amount);
});
policyIdMap.set(buffer_1.Buffer.from(policyId, "hex"), tokenMap);
});
return policyIdMap;
};
exports.encodeOutputTokens = encodeOutputTokens;
const encodeMint = (mints) => {
const policyIdMap = new Map();
for (const mint of mints) {
const tokenMap = new Map();
mint.assets.forEach(({ assetName, amount }) => {
tokenMap.set(buffer_1.Buffer.from(assetName, "hex"), amount);
});
policyIdMap.set(buffer_1.Buffer.from(mint.policyId, "hex"), tokenMap);
}
return policyIdMap;
};
exports.encodeMint = encodeMint;
const encodeOutput = (output) => {
const amount = output.tokens.length > 0 ? [output.amount, (0, exports.encodeOutputTokens)(output.tokens)] : output.amount;
// Babbage era output with inline datum and refScript support
const encodedOutput = new Map();
encodedOutput.set(internal_types_1.OutputItemType.ADDRESS, output.address.getBytes());
encodedOutput.set(internal_types_1.OutputItemType.VALUE, amount);
const plutusDataHash = output.plutusDataHash
? buffer_1.Buffer.from(output.plutusDataHash, "hex")
: undefined;
if (plutusDataHash) {
encodedOutput.set(internal_types_1.OutputItemType.DATUM_OPTION, [0, plutusDataHash]);
}
else if (output.plutusData) {
const encodedPlutusData = cbors.Encoder.encode((0, exports.encodePlutusData)(output.plutusData));
encodedOutput.set(internal_types_1.OutputItemType.DATUM_OPTION, [1, new cbors.CborTag(encodedPlutusData, 24)]);
}
let refScript;
if (output.plutusScript) {
if (output.plutusScript.type === types_1.PlutusScriptType.PlutusScriptV1) {
refScript = [1, buffer_1.Buffer.from(output.plutusScript.cborHex, "hex")];
}
else if (output.plutusScript.type === types_1.PlutusScriptType.PlutusScriptV2) {
refScript = [2, buffer_1.Buffer.from(output.plutusScript.cborHex, "hex")];
}
else if (output.plutusScript.type === types_1.PlutusScriptType.PlutusScriptV3) {
refScript = [3, buffer_1.Buffer.from(output.plutusScript.cborHex, "hex")];
}
}
else if (output.nativeScript) {
const encodedNativeScript = cbors.Encoder.encode((0, exports.encodeNativeScript)(output.nativeScript));
refScript = [0, encodedNativeScript];
}
if (refScript) {
const refScriptCbor = cbors.Encoder.encode(refScript);
encodedOutput.set(internal_types_1.OutputItemType.SCRIPT_REF, new cbors.CborTag(refScriptCbor, 24));
}
return encodedOutput;
};
exports.encodeOutput = encodeOutput;
const encodeOutputs = (outputs) => {
const encodedOutputs = outputs.map((output) => {
return (0, exports.encodeOutput)(output);
}, []);
return encodedOutputs;
};
exports.encodeOutputs = encodeOutputs;
const encodeWithdrawals = (withdrawals) => {
const encodedWithdrawals = new Map();
withdrawals.forEach((withdrawal) => {
const stakingAddress = withdrawal.rewardAccount.getBytes();
encodedWithdrawals.set(stakingAddress, withdrawal.amount);
});
return encodedWithdrawals;
};
exports.encodeWithdrawals = encodeWithdrawals;
const encodeDRep = (drep) => {
let encodedDRep;
switch (drep.type) {
case types_1.DRepType.ADDRESS:
encodedDRep = [0, drep.key];
break;
case types_1.DRepType.SCRIPT:
encodedDRep = [1, drep.key];
break;
case types_1.DRepType.ABSTAIN:
encodedDRep = [2];
break;
case types_1.DRepType.NO_CONFIDENCE:
encodedDRep = [3];
break;
default:
throw new Error("Invalid DRep type");
}
return encodedDRep;
};
exports.encodeDRep = encodeDRep;
const encodeAnchor = (anchor) => {
if (anchor) {
return [anchor.url, anchor.hash];
}
return null;
};
exports.encodeAnchor = encodeAnchor;
const encodeCredential = (credential) => {
const encodedCredential = [credential.type, credential.hash];
return encodedCredential;
};
exports.encodeCredential = encodeCredential;
const encodeStakeRegistrationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
return [types_1.CertificateType.STAKE_REGISTRATION, encodedStakeCredential];
};
exports.encodeStakeRegistrationCertificate = encodeStakeRegistrationCertificate;
const encodeStakeDeRegistrationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
return [types_1.CertificateType.STAKE_DE_REGISTRATION, encodedStakeCredential];
};
exports.encodeStakeDeRegistrationCertificate = encodeStakeDeRegistrationCertificate;
const encodeStakeDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
const poolHash = buffer_1.Buffer.from(certificate.cert.poolHash, "hex");
return [types_1.CertificateType.STAKE_DELEGATION, encodedStakeCredential, poolHash];
};
exports.encodeStakeDelegationCertificate = encodeStakeDelegationCertificate;
const encodeStakeKeyRegistrationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
return [types_1.CertificateType.STAKE_KEY_REGISTRATION, encodedStakeCredential, certificate.cert.deposit];
};
exports.encodeStakeKeyRegistrationCertificate = encodeStakeKeyRegistrationCertificate;
const encodeStakeKeyDeRegistrationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
return [
types_1.CertificateType.STAKE_KEY_DE_REGISTRATION,
encodedStakeCredential,
certificate.cert.deposit,
];
};
exports.encodeStakeKeyDeRegistrationCertificate = encodeStakeKeyDeRegistrationCertificate;
const encodeVoteDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
const encodedDRep = (0, exports.encodeDRep)(certificate.cert.dRep);
return [types_1.CertificateType.VOTE_DELEGATION, encodedStakeCredential, encodedDRep];
};
exports.encodeVoteDelegationCertificate = encodeVoteDelegationCertificate;
const encodeStakeVoteDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
const encodedDRep = (0, exports.encodeDRep)(certificate.cert.dRep);
return [
types_1.CertificateType.STAKE_VOTE_DELEG,
encodedStakeCredential,
certificate.cert.poolKeyHash,
encodedDRep,
];
};
exports.encodeStakeVoteDelegationCertificate = encodeStakeVoteDelegationCertificate;
const encodeStakeRegDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
return [
types_1.CertificateType.STAKE_REG_DELEG,
encodedStakeCredential,
certificate.cert.poolKeyHash,
certificate.cert.deposit,
];
};
exports.encodeStakeRegDelegationCertificate = encodeStakeRegDelegationCertificate;
const encodeVoteRegDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
const encodedDRep = (0, exports.encodeDRep)(certificate.cert.dRep);
return [
types_1.CertificateType.VOTE_REG_DELEG,
encodedStakeCredential,
encodedDRep,
certificate.cert.deposit,
];
};
exports.encodeVoteRegDelegationCertificate = encodeVoteRegDelegationCertificate;
const encodeStakeVoteRegDelegationCertificate = (certificate) => {
const encodedStakeCredential = (0, exports.encodeCredential)(certificate.cert.stakeCredential);
const encodedDRep = (0, exports.encodeDRep)(certificate.cert.dRep);
return [
types_1.CertificateType.STAKE_VOTE_REG_DELEG,
encodedStakeCredential,
certificate.cert.poolKeyHash,
encodedDRep,
certificate.cert.deposit,
];
};
exports.encodeStakeVoteRegDelegationCertificate = encodeStakeVoteRegDelegationCertificate;
const encodeCommitteeAuthHotCertificate = (certificate) => {
const encodedCommitteeColdCred = (0, exports.encodeCredential)(certificate.cert.coldCredential);
const encodedCommitteeHotCred = (0, exports.encodeCredential)(certificate.cert.hotCredential);
return [types_1.CertificateType.COMMITTEE_AUTH_HOT, encodedCommitteeColdCred, encodedCommitteeHotCred];
};
exports.encodeCommitteeAuthHotCertificate = encodeCommitteeAuthHotCertificate;
const encodeCommitteeResignColdCertificate = (certificate) => {
const encodedCommitteeColdCred = (0, exports.encodeCredential)(certificate.cert.coldCredential);
return [
types_1.CertificateType.COMMITTEE_RESIGN_COLD,
encodedCommitteeColdCred,
(0, exports.encodeAnchor)(certificate.cert.anchor),
];
};
exports.encodeCommitteeResignColdCertificate = encodeCommitteeResignColdCertificate;
const encodeDRepRegCertificate = (certificate) => {
const encodedDRepCred = (0, exports.encodeCredential)(certificate.cert.dRepCredential);
return [
types_1.CertificateType.DREP_REG,
encodedDRepCred,
certificate.cert.deposit,
(0, exports.encodeAnchor)(certificate.cert.anchor),
];
};
exports.encodeDRepRegCertificate = encodeDRepRegCertificate;
const encodeDRepDeRegCertificate = (certificate) => {
const encodedDRepCred = (0, exports.encodeCredential)(certificate.cert.dRepCredential);
return [types_1.CertificateType.DREP_DE_REG, encodedDRepCred, certificate.cert.deposit];
};
exports.encodeDRepDeRegCertificate = encodeDRepDeRegCertificate;
const encodeDRepUpdateCertificate = (certificate) => {
const encodedDRepCred = (0, exports.encodeCredential)(certificate.cert.dRepCredential);
return [types_1.CertificateType.DREP_UPDATE, encodedDRepCred, (0, exports.encodeAnchor)(certificate.cert.anchor)];
};
exports.encodeDRepUpdateCertificate = encodeDRepUpdateCertificate;
const encodeCertificates = (certificates) => {
const encodedCertificates = [];
certificates.forEach((certificate) => {
switch (certificate.type) {
case types_1.CertificateType.STAKE_REGISTRATION: {
encodedCertificates.push((0, exports.encodeStakeRegistrationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_DE_REGISTRATION: {
encodedCertificates.push((0, exports.encodeStakeDeRegistrationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_DELEGATION: {
encodedCertificates.push((0, exports.encodeStakeDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_KEY_REGISTRATION: {
encodedCertificates.push((0, exports.encodeStakeKeyRegistrationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_KEY_DE_REGISTRATION: {
encodedCertificates.push((0, exports.encodeStakeKeyDeRegistrationCertificate)(certificate));
break;
}
case types_1.CertificateType.VOTE_DELEGATION: {
encodedCertificates.push((0, exports.encodeVoteDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_VOTE_DELEG: {
encodedCertificates.push((0, exports.encodeStakeVoteDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_REG_DELEG: {
encodedCertificates.push((0, exports.encodeStakeRegDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.VOTE_REG_DELEG: {
encodedCertificates.push((0, exports.encodeVoteRegDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.STAKE_VOTE_REG_DELEG: {
encodedCertificates.push((0, exports.encodeStakeVoteRegDelegationCertificate)(certificate));
break;
}
case types_1.CertificateType.COMMITTEE_AUTH_HOT: {
encodedCertificates.push((0, exports.encodeCommitteeAuthHotCertificate)(certificate));
break;
}
case types_1.CertificateType.COMMITTEE_RESIGN_COLD: {
encodedCertificates.push((0, exports.encodeCommitteeResignColdCertificate)(certificate));
break;
}
case types_1.CertificateType.DREP_REG: {
encodedCertificates.push((0, exports.encodeDRepRegCertificate)(certificate));
break;
}
case types_1.CertificateType.DREP_DE_REG: {
encodedCertificates.push((0, exports.encodeDRepDeRegCertificate)(certificate));
break;
}
case types_1.CertificateType.DREP_UPDATE: {
encodedCertificates.push((0, exports.encodeDRepUpdateCertificate)(certificate));
break;
}
default:
throw new Error("unsupported certificate type");
}
});
return encodedCertificates;
};
exports.encodeCertificates = encodeCertificates;
const encodeVKeyWitness = (vKeyWitness) => {
// create a map of unique v keys
const vKeyMap = new Map();
for (const vKey of vKeyWitness) {
vKeyMap.set(vKey.publicKey.toString("hex"), vKey.signature);
}
const encodedVKeyWitness = [];
for (const [vKey, sig] of vKeyMap) {
encodedVKeyWitness.push([buffer_1.Buffer.from(vKey, "hex"), sig]);
}
return encodedVKeyWitness;
};
exports.encodeVKeyWitness = encodeVKeyWitness;
const encodeWitnesses = (vKeyWitness, inputs, plutusDataList, plutusScriptMap, nativeScripts, mints) => {
const encodedWitnesses = new Map();
if (vKeyWitness.length > 0) {
encodedWitnesses.set(types_1.WitnessType.V_KEY_WITNESS, (0, exports.encodeVKeyWitness)(vKeyWitness));
}
const sortedInputs = lodash_1.default.orderBy(inputs, ["txId", "index"], ["asc", "asc"]);
const sortedMints = lodash_1.default.orderBy(mints, ["policyId"], ["asc"]);
const encodedRedeemers = [];
const encodedPlutusDataMap = new Map();
for (const d of plutusDataList) {
const encodedPlutusData = (0, exports.encodePlutusData)(d);
const edCbor = cbors.Encoder.encode(encodedPlutusData);
const edHash = (0, crypto_1.hash32)(edCbor);
encodedPlutusDataMap.set(edHash.toString("hex"), encodedPlutusData);
}
for (const [index, input] of sortedInputs.entries()) {
if (input.redeemer) {
const encodedPlutusData = (0, exports.encodePlutusData)(input.redeemer.plutusData);
encodedRedeemers.push([
internal_types_1.RedeemerTag.SPEND,
index,
encodedPlutusData,
[input.redeemer.exUnits.mem, input.redeemer.exUnits.steps],
]);
}
}
for (const [index, mint] of sortedMints.entries()) {
if (mint.plutusScript && mint.redeemer) {
const encodedPlutusData = (0, exports.encodePlutusData)(mint.redeemer.plutusData);
encodedRedeemers.push([
internal_types_1.RedeemerTag.MINT,
index,
encodedPlutusData,
[mint.redeemer.exUnits.mem, mint.redeemer.exUnits.steps],
]);
}
}
const encodedPlutusDataList = [];
for (const [, encodedPlutusData] of encodedPlutusDataMap) {
encodedPlutusDataList.push(encodedPlutusData);
}
const encodedPlutusScriptsV1 = [];
const encodedPlutusScriptsV2 = [];
for (const [script, scriptType] of plutusScriptMap) {
if (scriptType === types_1.PlutusScriptType.PlutusScriptV1) {
const pls = cbors.Decoder.decode(buffer_1.Buffer.from(script, "hex"));
encodedPlutusScriptsV1.push(pls.value);
}
else if (scriptType === types_1.PlutusScriptType.PlutusScriptV2) {
const pls = cbors.Decoder.decode(buffer_1.Buffer.from(script, "hex"));
encodedPlutusScriptsV2.push(pls.value);
}
else {
throw new Error("Unsupported PlutusScript Version");
}
}
if (encodedPlutusScriptsV1.length) {
encodedWitnesses.set(types_1.WitnessType.PLUTUS_SCRIPT_V1, encodedPlutusScriptsV1);
}
if (encodedPlutusScriptsV2.length) {
encodedWitnesses.set(types_1.WitnessType.PLUTUS_SCRIPT_V2, encodedPlutusScriptsV2);
}
const encodedNativeScriptMap = new Map();
for (const ns of nativeScripts) {
const encodedNativeScript = (0, exports.encodeNativeScript)(ns);
const nsCbor = cbors.Encoder.encode(encodedNativeScript);
encodedNativeScriptMap.set(nsCbor.toString("hex"), encodedNativeScript);
}
const encodedNativeScripts = [];
for (const [, encodedNS] of encodedNativeScriptMap) {
encodedNativeScripts.push(encodedNS);
}
if (encodedNativeScripts.length) {
encodedWitnesses.set(types_1.WitnessType.NATIVE_SCRIPT, encodedNativeScripts);
}
if (encodedPlutusDataList.length)
encodedWitnesses.set(types_1.WitnessType.PLUTUS_DATA, encodedPlutusDataList);
if (encodedRedeemers.length) {
encodedWitnesses.set(types_1.WitnessType.REDEEMER, encodedRedeemers);
}
return encodedWitnesses;
};
exports.encodeWitnesses = encodeWitnesses;
const encodeMetadata = (metadataArray) => {
const encodedMetadata = new Map();
for (const metadata of metadataArray) {
encodedMetadata.set(metadata.label, (0, helpers_1.sanitizeMetadata)(metadata.data));
}
return encodedMetadata;
};
exports.encodeMetadata = encodeMetadata;
const encodeAuxiliaryData = (auxiliaryData) => {
const encodedMetadata = (0, exports.encodeMetadata)(auxiliaryData.metadata);
const auxDataMap = new Map();
auxDataMap.set(0, encodedMetadata);
return new cbors.CborTag(auxDataMap, 259);
};
exports.encodeAuxiliaryData = encodeAuxiliaryData;
const PlutusDataObjectKeys = ["constructor", "fields"];
const createConstructor = (pConstructor) => {
const keys = Object.keys(pConstructor);
if (!(keys.every((val) => PlutusDataObjectKeys.includes(val)) &&
pConstructor.fields instanceof Array)) {
throw new Error("Invalid PlutusData supplied");
}
// array is definite length if empty
let fields = [];
if (pConstructor.fields.length > 0) {
fields = new cbors.IndefiniteArray();
for (const field of pConstructor.fields) {
fields.push((0, exports.encodePlutusData)(field));
}
}
if (pConstructor.constructor < 7) {
return new cbors.CborTag(fields, 121 + pConstructor.constructor);
}
if (pConstructor.constructor > 6 && pConstructor.constructor < 128) {
const mask = pConstructor.constructor - 7;
return new cbors.CborTag(fields, 1280 + mask);
}
return new cbors.CborTag([pConstructor.constructor, fields], 102);
};
const encodePlutusData = (plutusData) => {
if (plutusData instanceof Array) {
if (plutusData.length > 0) {
const ary = new cbors.IndefiniteArray();
for (const d of plutusData) {
ary.push((0, exports.encodePlutusData)(d));
}
return ary;
}
return [];
}
if (plutusData instanceof Uint8Array) {
return buffer_1.Buffer.from(plutusData);
}
if (plutusData instanceof buffer_1.Buffer) {
return plutusData;
}
if (typeof plutusData === "string") {
throw new Error("String not supported in PlutusData");
}
// TODO: map is also an object, check map first, maybe requires a proper fix
else if (plutusData instanceof Map) {
if (plutusData.size > 0) {
const map = new cbors.IndefiniteMap();
for (const [key, value] of plutusData.entries()) {
map.set(key, (0, exports.encodePlutusData)(value));
}
return map;
}
return new Map();
}
else if (bignumber_js_1.default.isBigNumber(plutusData)) {
return plutusData;
}
else if (plutusData instanceof Object) {
const constructorObject = plutusData;
const constructor = createConstructor(constructorObject);
return constructor;
}
else {
return plutusData;
}
};
exports.encodePlutusData = encodePlutusData;
const encodeLanguageViews = (languageView, plutusV1, plutusV2, plutusV3) => {
const encodedLanguageView = new Map();
if (plutusV1) {
// The encoding is Plutus V1 Specific
// indefinite array encoding
const indefCostMdls = cbors.IndefiniteArray.from(languageView.PlutusScriptV1);
// for V1, encode values before adding to view map
const cborCostMdls = cbors.Encoder.encode(indefCostMdls);
const langId = cbors.Encoder.encode(0);
// Plutus V1
encodedLanguageView.set(langId, cborCostMdls);
}
if (plutusV2) {
// The encoding is Plutus V2 Specific
encodedLanguageView.set(1, languageView.PlutusScriptV2);
}
if (plutusV3) {
encodedLanguageView.set(2, languageView.PlutusScriptV3);
}
return cbors.Encoder.encode(encodedLanguageView).toString("hex");
};
exports.encodeLanguageViews = encodeLanguageViews;
const encodeNativeScripts = (nativeScripts) => {
const encodedNativeScripts = [];
for (const ns of nativeScripts) {
encodedNativeScripts.push((0, exports.encodeNativeScript)(ns));
}
return encodedNativeScripts;
};
const encodeNativeScript = (nativeScript) => {
if (nativeScript.pubKeyHash) {
return [0, buffer_1.Buffer.from(nativeScript.pubKeyHash, "hex")];
}
if (nativeScript.all) {
return [1, encodeNativeScripts(nativeScript.all)];
}
if (nativeScript.any) {
return [2, encodeNativeScripts(nativeScript.any)];
}
if (nativeScript.n) {
return [3, nativeScript.n, encodeNativeScripts(nativeScript.k)];
}
if (nativeScript.invalidBefore) {
return [4, nativeScript.invalidBefore];
}
if (nativeScript.invalidAfter) {
return [5, nativeScript.invalidAfter];
}
throw new Error("Invalid native script");
};
exports.encodeNativeScript = encodeNativeScript;
const encodeVotingProcedures = (votingProcedures) => {
// combine voting procedures with the same voter
const vpMap = {};
for (const vps of votingProcedures) {
const voter = `${vps.voter.key.hash.toString("hex")}#${vps.voter.type}`;
if (!vpMap[voter]) {
vpMap[voter] = { voter: vps.voter, votes: vps.votes };
}
else {
vpMap[voter].votes.push(...vps.votes);
}
}
// filter out duplicate votes, latest one wins
const filteredVotingProcedures = [];
for (const { voter, votes } of Object.values(vpMap)) {
const voteMap = {};
for (const vote of votes) {
const govActionId = `${vote.govActionId.txId.toString("hex")}#${vote.govActionId.index}`;
voteMap[govActionId] = vote;
}
filteredVotingProcedures.push({
voter: voter,
votes: Object.values(voteMap),
});
}
// encode voting procedures as per conway CDDL
const encodedVotingProcedures = new Map();
for (const { voter, votes } of Object.values(vpMap)) {
const encodedVoter = [voter.type, voter.key.hash];
const encodedVotes = new Map();
for (const vote of votes) {
const encodedGovActionId = [
vote.govActionId.txId,
vote.govActionId.index,
];
const encodedVotingProcedure = [vote.vote, (0, exports.encodeAnchor)(vote.anchor)];
encodedVotes.set(encodedGovActionId, encodedVotingProcedure);
}
encodedVotingProcedures.set(encodedVoter, encodedVotes);
}
return encodedVotingProcedures;
};
exports.encodeVotingProcedures = encodeVotingProcedures;
// encode protocol param change update data following the Conway CDDL specification
const encodeProtocolParamUpdate = (ppu) => {
const encodedParamUpdate = new Map();
if (ppu.minFeeA) {
encodedParamUpdate.set(0, ppu.minFeeA);
}
if (ppu.minFeeB) {
encodedParamUpdate.set(1, ppu.minFeeB);
}
if (ppu.maxBlockBodySize) {
encodedParamUpdate.set(2, ppu.maxBlockBodySize);
}
if (ppu.maxTransactionSize) {
encodedParamUpdate.set(3, ppu.maxTransactionSize);
}
if (ppu.maxBlockHeaderSize) {
encodedParamUpdate.set(4, ppu.maxBlockHeaderSize);
}
if (ppu.stakeKeyDeposit) {
encodedParamUpdate.set(5, ppu.stakeKeyDeposit);
}
if (ppu.poolDeposit) {
encodedParamUpdate.set(6, ppu.poolDeposit);
}
if (ppu.poolRetireMaxEpoch) {
encodedParamUpdate.set(7, ppu.poolRetireMaxEpoch);
}
if (ppu.n) {
encodedParamUpdate.set(8, ppu.n);
}
if (ppu.pledgeInfluence) {
encodedParamUpdate.set(9, new cbors.CborTag(ppu.pledgeInfluence, 30));
}
if (ppu.expansionRate) {
encodedParamUpdate.set(10, new cbors.CborTag(ppu.expansionRate, 30));
}
if (ppu.treasuryGrowthRate) {
encodedParamUpdate.set(11, new cbors.CborTag(ppu.treasuryGrowthRate, 30));
}
if (ppu.minPoolCost) {
encodedParamUpdate.set(16, ppu.minPoolCost);
}
if (ppu.adaPerUtxoByte) {
encodedParamUpdate.set(17, ppu.adaPerUtxoByte);
}
if (ppu.costMdls) {
const encodedCostMdls = new Map();
if (ppu.costMdls.plutusV1) {
encodedCostMdls.set(0, ppu.costMdls.plutusV1);
}
if (ppu.costMdls.plutusV2) {
encodedCostMdls.set(1, ppu.costMdls.plutusV2);
}
if (ppu.costMdls.plutusV3) {
encodedCostMdls.set(2, ppu.costMdls.plutusV3);
}
encodedParamUpdate.set(18, encodedCostMdls);
}
if (ppu.exUnitPrices) {
const encodedExUnitPrices = [
new cbors.CborTag(ppu.exUnitPrices.mem, 30),
new cbors.CborTag(ppu.exUnitPrices.steps, 30),
];
encodedParamUpdate.set(19, encodedExUnitPrices);
}
if (ppu.maxTxExUnits) {
encodedParamUpdate.set(20, [ppu.maxTxExUnits.mem, ppu.maxTxExUnits.steps]);
}
if (ppu.maxBlockExUnits) {
encodedParamUpdate.set(21, [ppu.maxBlockExUnits.mem, ppu.maxBlockExUnits.steps]);
}
if (ppu.maxValueSize) {
encodedParamUpdate.set(22, ppu.maxValueSize);
}
if (ppu.collateralPercent) {
encodedParamUpdate.set(23, ppu.collateralPercent);
}
if (ppu.maxCollateralInputs) {
encodedParamUpdate.set(24, ppu.maxCollateralInputs);
}
if (ppu.poolVotingThreshold) {
encodedParamUpdate.set(25, [
ppu.poolVotingThreshold.motionNoConfidence,
ppu.poolVotingThreshold.committeeNormal,
ppu.poolVotingThreshold.committeeNoConfidence,
ppu.poolVotingThreshold.hfInitiation,
ppu.poolVotingThreshold.securityParamVoting,
]);
}
if (ppu.dRepVotingThreshold) {
encodedParamUpdate.set(26, [
ppu.dRepVotingThreshold.motionNoConfidence,
ppu.dRepVotingThreshold.committeeNormal,
ppu.dRepVotingThreshold.committeeNoConfidence,
ppu.dRepVotingThreshold.updateConstitution,
ppu.dRepVotingThreshold.hfInitiation,
ppu.dRepVotingThreshold.networkParamVoting,
ppu.dRepVotingThreshold.economicParamVoting,
ppu.dRepVotingThreshold.technicalParamVoting,
ppu.dRepVotingThreshold.govParamVoting,
ppu.dRepVotingThreshold.treasuryWithdrawal,
]);
}
if (ppu.minCommitteeSize) {
encodedParamUpdate.set(27, ppu.minCommitteeSize);
}
if (ppu.committeeTermLimit) {
encodedParamUpdate.set(28, ppu.committeeTermLimit);
}
if (ppu.govActionValidity) {
encodedParamUpdate.set(29, ppu.govActionValidity);
}
if (ppu.govActionDeposit) {
encodedParamUpdate.set(30, ppu.govActionDeposit);
}
if (ppu.dRepDeposit) {
encodedParamUpdate.set(31, ppu.dRepDeposit);
}
if (ppu.dRepInactivity) {
encodedParamUpdate.set(32, ppu.dRepInactivity);
}
if (ppu.refScriptCostByte) {
encodedParamUpdate.set(33, new cbors.CborTag(ppu.refScriptCostByte, 30));
}
return encodedParamUpdate;
};
exports.encodeProtocolParamUpdate = encodeProtocolParamUpdate;
// encode proposal procedure following the Conway CDDL specification
const encodeProposalProcedures = (proposalProcedures) => {
const encodedProposalProcedures = [];
for (const pp of proposalProcedures) {
let encodedGovAction;
switch (pp.govAction.type) {
case types_1.GovActionType.PARAM_CHANGE_ACTION: {
let encodedGovActionId = null;
if (pp.govAction.action.prevActionId) {
encodedGovActionId = [
pp.govAction.action.prevActionId.txId,
pp.govAction.action.prevActionId.index,
];
}
const encodedParamUpdate = (0, exports.encodeProtocolParamUpdate)(pp.govAction.action.protocolParamUpdate);
encodedGovAction = [
0,
encodedGovActionId,
encodedParamUpdate,
pp.govAction.action.policyHash,
];
break;
}
case types_1.GovActionType.HF_INIT_ACTION: {
let encodedGovActionId = null;
if (pp.govAction.action.prevActionId) {
encodedGovActionId = [
pp.govAction.action.prevActionId.txId,
pp.govAction.action.prevActionId.index,
];
}
encodedGovAction = [1, encodedGovActionId, pp.govAction.action.protocolVersion];
break;
}
case types_1.GovActionType.TREASURY_WITHDRAW_ACTION: {
const encodedWithdrawals = new Map();
for (const w of pp.govAction.action.withdrawals) {
encodedWithdrawals.set(w.rewardAccount, w.amount);
}
encodedGovAction = [2, encodedWithdrawals, pp.govAction.action.policyHash];
break;
}
case types_1.GovActionType.NO_CONFIDENCE_ACTION: {
let encodedGovActionId = null;
if (pp.govAction.action.prevActionId) {
encodedGovActionId = [
pp.govAction.action.prevActionId.txId,
pp.govAction.action.prevActionId.index,
];
}
encodedGovAction = [3, encodedGovActionId];
break;
}
case types_1.GovActionType.UPDATE_COMMITTEE_ACTION: {
let encodedGovActionId = null;
if (pp.govAction.action.prevActionId) {
encodedGovActionId = [
pp.govAction.action.prevActionId.txId,
pp.govAction.action.prevActionId.index,
];
}
const encodedRemovedColdCreds = pp.govAction.action.removeColdCreds.map((cred) => {
return (0, exports.encodeCredential)(cred);
});
const encodedAddColdCreds = new Map();
for (const addColdCred of pp.govAction.action.addColdCreds) {
encodedAddColdCreds.set((0, exports.encodeCredential)(addColdCred.credential), addColdCred.epoch);
}
encodedGovAction = [
4,
encodedGovActionId,
encodedRemovedColdCreds,
encodedAddColdCreds,
new cbors.CborTag(pp.govAction.action.threshold, 30),
];
break;
}
case types_1.GovActionType.NEW_CONSTITUTION_ACTION: {
let encodedGovActionId = null;
if (pp.govAction.action.prevActionId) {
encodedGovActionId = [
pp.govAction.action.prevActionId.txId,
pp.govAction.action.prevActionId.index,
];
}
const encodedConstitution = [
(0, exports.encodeAnchor)(pp.govAction.action.constitution.anchor),
pp.govAction.action.constitution.scriptHash,
];
encodedGovAction = [5, encodedGovActionId, encodedConstitution];
break;
}
case types_1.GovActionType.INFO_ACTION: {
encodedGovAction = [6];
break;
}
default:
throw new Error("Unknown type of gov action");
}
encodedProposalProcedures.push([
pp.deposit,
pp.rewardAccount,
encodedGovAction,
(0, exports.encodeAnchor)(pp.anchor),
]);
}
};
exports.encodeProposalProcedures = encodeProposalProcedures;