@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/packages/transact/src/transactions/transaction-meta.js

@@ -0,0 +1,1013 @@
+const require_address = require('../../../common/src/address.js');
+const require_codec = require('../../../common/src/codecs/codec.js');
+const require_address$1 = require('../../../common/src/codecs/primitives/address.js');
+const require_bigint = require('../../../common/src/codecs/primitives/bigint.js');
+const require_boolean = require('../../../common/src/codecs/primitives/boolean.js');
+const require_bytes = require('../../../common/src/codecs/primitives/bytes.js');
+const require_fixed_bytes = require('../../../common/src/codecs/primitives/fixed-bytes.js');
+const require_number = require('../../../common/src/codecs/primitives/number.js');
+const require_wire = require('../../../common/src/codecs/wire.js');
+const require_string = require('../../../common/src/codecs/primitives/string.js');
+const require_array = require('../../../common/src/codecs/composite/array.js');
+const require_map = require('../../../common/src/codecs/composite/map.js');
+const require_object_model = require('../../../common/src/codecs/models/object-model.js');
+const require_transaction_type = require('./transaction-type.js');
+
+//#region packages/transact/src/transactions/transaction-meta.ts
+var TransactionTypeCodec = class extends require_codec.Codec {
+	defaultValue() {
+		return require_transaction_type.TransactionType.Unknown;
+	}
+	toEncoded(value, _format) {
+		switch (value) {
+			case require_transaction_type.TransactionType.Payment: return "pay";
+			case require_transaction_type.TransactionType.AssetTransfer: return "axfer";
+			case require_transaction_type.TransactionType.AssetFreeze: return "afrz";
+			case require_transaction_type.TransactionType.AssetConfig: return "acfg";
+			case require_transaction_type.TransactionType.KeyRegistration: return "keyreg";
+			case require_transaction_type.TransactionType.AppCall: return "appl";
+			case require_transaction_type.TransactionType.StateProof: return "stpf";
+			case require_transaction_type.TransactionType.Heartbeat: return "hb";
+			default: return "unknown";
+		}
+	}
+	fromEncoded(value, _format) {
+		switch (require_wire.normalizeWireString(value)) {
+			case "pay": return require_transaction_type.TransactionType.Payment;
+			case "axfer": return require_transaction_type.TransactionType.AssetTransfer;
+			case "afrz": return require_transaction_type.TransactionType.AssetFreeze;
+			case "acfg": return require_transaction_type.TransactionType.AssetConfig;
+			case "keyreg": return require_transaction_type.TransactionType.KeyRegistration;
+			case "appl": return require_transaction_type.TransactionType.AppCall;
+			case "stpf": return require_transaction_type.TransactionType.StateProof;
+			case "hb": return require_transaction_type.TransactionType.Heartbeat;
+			default: return require_transaction_type.TransactionType.Unknown;
+		}
+	}
+};
+var TransactionDataCodec = class extends require_codec.Codec {
+	transactionDataCodec;
+	constructor(transactionType, transactionTypeDataMetadata) {
+		super();
+		this.transactionType = transactionType;
+		this.transactionDataCodec = new require_object_model.ObjectModelCodec(transactionTypeDataMetadata);
+	}
+	defaultValue() {}
+	toEncoded(value, format) {
+		if (!value) throw new Error("Transaction data is missing");
+		return this.transactionDataCodec.encode(value, format);
+	}
+	fromEncoded(value, format) {
+		if (value.type === void 0) throw new Error("Transaction is missing type field");
+		if (require_wire.normalizeWireString(value.type) === this.transactionType.toString()) return this.transactionDataCodec.decode(value, format);
+	}
+};
+var AssetConfigDataCodec = class extends require_codec.Codec {
+	assetParamsCodec = new require_object_model.ObjectModelCodec(AssetParamsMeta);
+	defaultValue() {}
+	toEncoded(value, format) {
+		const result = {};
+		if (!value) throw new Error("Transaction is not an asset config");
+		const { assetId, ...assetParams } = value;
+		const encodedAssetId = require_bigint.bigIntCodec.encodeOptional(assetId, format);
+		if (encodedAssetId !== void 0) result.caid = encodedAssetId;
+		const encodedParams = this.assetParamsCodec.encodeOptional(assetParams, format);
+		if (encodedParams && Object.keys(encodedParams).length > 0) result.apar = encodedParams;
+		return result;
+	}
+	fromEncoded(value, format) {
+		if (value.type === void 0) throw new Error("Transaction is missing type field");
+		const type = require_wire.normalizeWireString(value.type);
+		const caid = value.caid;
+		const apar = value.apar;
+		if (type !== require_transaction_type.TransactionType.AssetConfig || caid === void 0 && !apar) return;
+		return {
+			assetId: require_bigint.bigIntCodec.decode(caid, format),
+			...this.assetParamsCodec.decode(apar, format)
+		};
+	}
+	isDefaultValue(value) {
+		return value === void 0;
+	}
+};
+var AppCallDataCodec = class extends require_codec.Codec {
+	appCallFieldsCodec = new require_object_model.ObjectModelCodec(AppCallTransactionFieldsMeta);
+	defaultValue() {}
+	encodeResourceReferences(appId, resourceReferences, format) {
+		if (!resourceReferences || resourceReferences.length === 0) return void 0;
+		const accessList = [];
+		const ensure = (target) => {
+			for (let idx = 0; idx < accessList.length; idx++) {
+				const entry = accessList[idx];
+				const matchesAddress = !entry.d && !target.address || entry.d && target.address && require_address$1.addressCodec.decode(entry.d, format).equals(target.address);
+				const matchesAssetId = entry.s === void 0 && target.assetId === void 0 || entry.s !== void 0 && target.assetId !== void 0 && require_bigint.bigIntCodec.decode(entry.s, format) === target.assetId;
+				const matchesAppId = entry.p === void 0 && target.appId === void 0 || entry.p !== void 0 && target.appId !== void 0 && require_bigint.bigIntCodec.decode(entry.p, format) === target.appId;
+				if (matchesAddress && matchesAssetId && matchesAppId) return idx + 1;
+			}
+			if (target.address && !target.address.equals(require_address.Address.zeroAddress())) accessList.push({ d: require_address$1.addressCodec.encodeOptional(target.address, format) });
+			if (target.assetId !== void 0) accessList.push({ s: require_bigint.bigIntCodec.encodeOptional(target.assetId, format) });
+			if (target.appId !== void 0) accessList.push({ p: require_bigint.bigIntCodec.encodeOptional(target.appId, format) });
+			return accessList.length;
+		};
+		for (const resourceRef of resourceReferences) {
+			if (resourceRef.address || resourceRef.assetId !== void 0 || resourceRef.appId !== void 0) {
+				ensure(resourceRef);
+				continue;
+			}
+			if (resourceRef.holding) {
+				const holding = resourceRef.holding;
+				let addressIndex = 0;
+				if (holding.address && !holding.address.equals(require_address.Address.zeroAddress())) addressIndex = ensure({ address: holding.address });
+				const assetIndex = ensure({ assetId: holding.assetId });
+				accessList.push({ h: {
+					d: require_number.numberCodec.encodeOptional(addressIndex, format),
+					s: require_number.numberCodec.encodeOptional(assetIndex, format)
+				} });
+				continue;
+			}
+			if (resourceRef.locals) {
+				const locals = resourceRef.locals;
+				let addressIndex = 0;
+				if (locals.address && !locals.address.equals(require_address.Address.zeroAddress())) addressIndex = ensure({ address: locals.address });
+				let appIndex = 0;
+				if (locals.appId && locals.appId !== appId) appIndex = ensure({ appId: locals.appId });
+				if (addressIndex !== 0 || appIndex !== 0) accessList.push({ l: {
+					d: require_number.numberCodec.encodeOptional(addressIndex, format),
+					p: require_number.numberCodec.encodeOptional(appIndex, format)
+				} });
+				continue;
+			}
+			if (resourceRef.box) {
+				const box = resourceRef.box;
+				let appIndex = 0;
+				if (box.appId && box.appId !== appId) appIndex = ensure({ appId: box.appId });
+				accessList.push({ b: {
+					i: require_number.numberCodec.encodeOptional(appIndex, format),
+					n: require_bytes.bytesCodec.encodeOptional(box.name, format)
+				} });
+				continue;
+			}
+		}
+		return accessList.length > 0 ? accessList : void 0;
+	}
+	decodeResourceReferences(_wireResourceReferences, format) {
+		if (!_wireResourceReferences || _wireResourceReferences.length === 0) return [];
+		const result = [];
+		const wireResourceReferences = _wireResourceReferences.map((ref) => require_wire.normalizeWireObject(ref));
+		for (const ref of wireResourceReferences) {
+			const d = ref.d;
+			const s = ref.s;
+			const p = ref.p;
+			const _h = ref.h;
+			const h = _h ? require_wire.normalizeWireObject(_h) : void 0;
+			const _l = ref.l;
+			const l = _l ? require_wire.normalizeWireObject(_l) : void 0;
+			const _b = ref.b;
+			const b = _b ? require_wire.normalizeWireObject(_b) : void 0;
+			if (d) {
+				result.push({ address: require_address$1.addressCodec.decode(d, format) });
+				continue;
+			}
+			if (s !== void 0) {
+				result.push({ assetId: require_bigint.bigIntCodec.decode(s, format) });
+				continue;
+			}
+			if (p !== void 0) {
+				result.push({ appId: require_bigint.bigIntCodec.decode(p, format) });
+				continue;
+			}
+			if (h) {
+				const addrIdx = h.d ?? 0;
+				const assetIdx = h.s;
+				if (assetIdx === void 0) throw new Error("Access list holding reference is missing asset index");
+				const holdingAddress = addrIdx === 0 ? require_address.Address.zeroAddress() : require_address$1.addressCodec.decode(wireResourceReferences[addrIdx - 1].d, format);
+				const holdingAssetId = wireResourceReferences[assetIdx - 1].s;
+				result.push({ holding: {
+					assetId: require_bigint.bigIntCodec.decode(holdingAssetId, format),
+					address: holdingAddress
+				} });
+				continue;
+			}
+			if (l) {
+				const addrIdx = l.d ?? 0;
+				const appIdx = l.p ?? 0;
+				const localsAddress = addrIdx === 0 ? require_address.Address.zeroAddress() : require_address$1.addressCodec.decode(wireResourceReferences[addrIdx - 1].d, format);
+				const localsAppId = appIdx === 0 ? 0n : wireResourceReferences[appIdx - 1].p;
+				result.push({ locals: {
+					appId: require_bigint.bigIntCodec.decode(localsAppId, format),
+					address: localsAddress
+				} });
+				continue;
+			}
+			if (b) {
+				const boxAppIdx = b.i ?? 0;
+				const name = b.n;
+				if (!name) throw new Error("Access list box reference is missing name");
+				const boxAppId = boxAppIdx === 0 ? 0n : wireResourceReferences[boxAppIdx - 1].p;
+				result.push({ box: {
+					appId: require_bigint.bigIntCodec.decode(boxAppId, format),
+					name: require_bytes.bytesCodec.decode(name, format)
+				} });
+				continue;
+			}
+		}
+		return result;
+	}
+	encodeBoxReferences(appId, appReferences, boxReferences, format) {
+		if (!boxReferences || boxReferences.length === 0) return void 0;
+		const appRefs = appReferences ?? [];
+		return boxReferences.map((box) => {
+			const isCurrentApp = box.appId === 0n || box.appId === appId;
+			const index = isCurrentApp ? 0 : appRefs.indexOf(box.appId) + 1;
+			if (index === 0 && !isCurrentApp) throw new Error(`Box ref with appId ${box.appId} not in appReferences`);
+			return {
+				i: require_number.numberCodec.encodeOptional(index, format),
+				n: require_bytes.bytesCodec.encodeOptional(box.name, format)
+			};
+		});
+	}
+	decodeBoxReferences(appReferences, wireBoxReferences, format) {
+		if (!wireBoxReferences || wireBoxReferences.length === 0) return [];
+		return wireBoxReferences.map((_box) => {
+			const box = require_wire.normalizeWireObject(_box);
+			const boxIndex = box.i;
+			const boxName = box.n;
+			const index = boxIndex ?? 0;
+			let appId;
+			if (index === 0) appId = 0n;
+			else {
+				const foreignAppId = appReferences?.[index - 1];
+				if (foreignAppId === void 0) throw new Error(`Failed to find the app reference at index ${index - 1}`);
+				appId = require_bigint.bigIntCodec.decode(foreignAppId, format);
+			}
+			return {
+				appId,
+				name: require_bytes.bytesCodec.decode(boxName, format)
+			};
+		});
+	}
+	toEncoded(value, format) {
+		const result = {};
+		if (!value) throw new Error("Transaction is not an app call");
+		const encodedParams = this.appCallFieldsCodec.encodeOptional(value, format);
+		if (encodedParams && Object.keys(encodedParams).length > 0) Object.assign(result, encodedParams);
+		const wireBoxReferences = this.encodeBoxReferences(value.appId, value.appReferences, value.boxReferences, format);
+		if (wireBoxReferences) result.apbx = wireBoxReferences;
+		const wireAccessReferences = this.encodeResourceReferences(value.appId, value.accessReferences, format);
+		if (wireAccessReferences) result.al = wireAccessReferences;
+		return result;
+	}
+	fromEncoded(value, format) {
+		if (value.type === void 0) throw new Error("Transaction is missing type field");
+		if (require_wire.normalizeWireString(value.type) !== require_transaction_type.TransactionType.AppCall) return;
+		const appReferences = value.apfa;
+		const wireBoxReferences = value.apbx;
+		const wireAccessReferences = value.al;
+		const boxReferences = this.decodeBoxReferences(appReferences?.map((ar) => require_bigint.bigIntCodec.decode(ar, format)), wireBoxReferences, format);
+		const accessReferences = this.decodeResourceReferences(wireAccessReferences, format);
+		return {
+			...this.appCallFieldsCodec.decode(value, format),
+			...accessReferences.length > 0 && { accessReferences },
+			...boxReferences.length > 0 && { boxReferences }
+		};
+	}
+	isDefaultValue(value) {
+		return value === void 0;
+	}
+};
+const PaymentTransactionFieldsMeta = {
+	name: "PaymentTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "amount",
+			wireKey: "amt",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "receiver",
+			wireKey: "rcv",
+			optional: false,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "closeRemainderTo",
+			wireKey: "close",
+			optional: true,
+			codec: require_address$1.addressCodec
+		}
+	]
+};
+const AssetTransferTransactionFieldsMeta = {
+	name: "AssetTransferTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "assetId",
+			wireKey: "xaid",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "amount",
+			wireKey: "aamt",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "receiver",
+			wireKey: "arcv",
+			optional: false,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "assetSender",
+			wireKey: "asnd",
+			optional: true,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "closeRemainderTo",
+			wireKey: "aclose",
+			optional: true,
+			codec: require_address$1.addressCodec
+		}
+	]
+};
+const AssetFreezeTransactionFieldsMeta = {
+	name: "AssetFreezeTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "assetId",
+			wireKey: "faid",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "freezeTarget",
+			wireKey: "fadd",
+			optional: false,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "frozen",
+			wireKey: "afrz",
+			optional: false,
+			codec: require_boolean.booleanCodec
+		}
+	]
+};
+const KeyRegistrationTransactionFieldsMeta = {
+	name: "KeyRegistrationTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "voteKey",
+			wireKey: "votekey",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "selectionKey",
+			wireKey: "selkey",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "stateProofKey",
+			wireKey: "sprfkey",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes64Codec
+		},
+		{
+			name: "voteFirst",
+			wireKey: "votefst",
+			optional: true,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "voteLast",
+			wireKey: "votelst",
+			optional: true,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "voteKeyDilution",
+			wireKey: "votekd",
+			optional: true,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "nonParticipation",
+			wireKey: "nonpart",
+			optional: true,
+			codec: require_boolean.booleanCodec
+		}
+	]
+};
+const AssetParamsMeta = {
+	name: "AssetParams",
+	kind: "object",
+	fields: [
+		{
+			name: "total",
+			wireKey: "t",
+			optional: true,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "decimals",
+			wireKey: "dc",
+			optional: true,
+			codec: require_number.numberCodec
+		},
+		{
+			name: "defaultFrozen",
+			wireKey: "df",
+			optional: true,
+			codec: require_boolean.booleanCodec
+		},
+		{
+			name: "unitName",
+			wireKey: "un",
+			optional: true,
+			codec: require_string.stringCodec
+		},
+		{
+			name: "assetName",
+			wireKey: "an",
+			optional: true,
+			codec: require_string.stringCodec
+		},
+		{
+			name: "url",
+			wireKey: "au",
+			optional: true,
+			codec: require_string.stringCodec
+		},
+		{
+			name: "metadataHash",
+			wireKey: "am",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "manager",
+			wireKey: "m",
+			optional: true,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "reserve",
+			wireKey: "r",
+			optional: true,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "freeze",
+			wireKey: "f",
+			optional: true,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "clawback",
+			wireKey: "c",
+			optional: true,
+			codec: require_address$1.addressCodec
+		}
+	]
+};
+const StateSchemaMeta = {
+	name: "StateSchema",
+	kind: "object",
+	fields: [{
+		name: "numUints",
+		wireKey: "nui",
+		optional: false,
+		codec: require_number.numberCodec
+	}, {
+		name: "numByteSlices",
+		wireKey: "nbs",
+		optional: false,
+		codec: require_number.numberCodec
+	}]
+};
+const AppCallTransactionFieldsMeta = {
+	name: "AppCallTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "appId",
+			wireKey: "apid",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "onComplete",
+			wireKey: "apan",
+			optional: false,
+			codec: require_number.numberCodec
+		},
+		{
+			name: "approvalProgram",
+			wireKey: "apap",
+			optional: true,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "clearStateProgram",
+			wireKey: "apsu",
+			optional: true,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "globalStateSchema",
+			wireKey: "apgs",
+			optional: true,
+			codec: new require_object_model.ObjectModelCodec(StateSchemaMeta)
+		},
+		{
+			name: "localStateSchema",
+			wireKey: "apls",
+			optional: true,
+			codec: new require_object_model.ObjectModelCodec(StateSchemaMeta)
+		},
+		{
+			name: "extraProgramPages",
+			wireKey: "apep",
+			optional: true,
+			codec: require_number.numberCodec
+		},
+		{
+			name: "args",
+			wireKey: "apaa",
+			optional: true,
+			codec: require_array.bytesArrayCodec
+		},
+		{
+			name: "accountReferences",
+			wireKey: "apat",
+			optional: true,
+			codec: require_array.addressArrayCodec
+		},
+		{
+			name: "appReferences",
+			wireKey: "apfa",
+			optional: true,
+			codec: require_array.bigIntArrayCodec
+		},
+		{
+			name: "assetReferences",
+			wireKey: "apas",
+			optional: true,
+			codec: require_array.bigIntArrayCodec
+		},
+		{
+			name: "rejectVersion",
+			wireKey: "aprv",
+			optional: true,
+			codec: require_number.numberCodec
+		}
+	]
+};
+const MerkleArrayProofMeta = {
+	name: "MerkleArrayProof",
+	kind: "object",
+	fields: [
+		{
+			name: "path",
+			wireKey: "pth",
+			optional: false,
+			codec: require_array.bytesArrayCodec
+		},
+		{
+			name: "hashFactory",
+			wireKey: "hsh",
+			optional: false,
+			codec: new require_object_model.ObjectModelCodec({
+				name: "HashFactory",
+				kind: "object",
+				fields: [{
+					name: "hashType",
+					wireKey: "t",
+					optional: false,
+					codec: require_number.numberCodec
+				}]
+			})
+		},
+		{
+			name: "treeDepth",
+			wireKey: "td",
+			optional: false,
+			codec: require_number.numberCodec
+		}
+	]
+};
+const FalconVerifierMeta = {
+	name: "FalconVerifier",
+	kind: "object",
+	fields: [{
+		name: "publicKey",
+		wireKey: "k",
+		optional: false,
+		codec: require_fixed_bytes.fixedBytes1793Codec
+	}]
+};
+const SigslotCommitMeta = {
+	name: "SigslotCommit",
+	kind: "object",
+	fields: [{
+		name: "sig",
+		wireKey: "s",
+		optional: false,
+		codec: new require_object_model.ObjectModelCodec({
+			name: "FalconSignatureStruct",
+			kind: "object",
+			fields: [
+				{
+					name: "signature",
+					wireKey: "sig",
+					optional: false,
+					codec: require_bytes.bytesCodec
+				},
+				{
+					name: "vectorCommitmentIndex",
+					wireKey: "idx",
+					optional: false,
+					codec: require_bigint.bigIntCodec
+				},
+				{
+					name: "proof",
+					wireKey: "prf",
+					optional: false,
+					codec: new require_object_model.ObjectModelCodec(MerkleArrayProofMeta)
+				},
+				{
+					name: "verifyingKey",
+					wireKey: "vkey",
+					optional: false,
+					codec: new require_object_model.ObjectModelCodec(FalconVerifierMeta)
+				}
+			]
+		})
+	}, {
+		name: "lowerSigWeight",
+		wireKey: "l",
+		optional: false,
+		codec: require_bigint.bigIntCodec
+	}]
+};
+const ParticipantMeta = {
+	name: "Participant",
+	kind: "object",
+	fields: [{
+		name: "verifier",
+		wireKey: "p",
+		optional: false,
+		codec: new require_object_model.ObjectModelCodec({
+			name: "MerkleSignatureVerifier",
+			kind: "object",
+			fields: [{
+				name: "commitment",
+				wireKey: "cmt",
+				optional: false,
+				codec: require_fixed_bytes.fixedBytes64Codec
+			}, {
+				name: "keyLifetime",
+				wireKey: "lf",
+				optional: false,
+				codec: require_bigint.bigIntCodec
+			}]
+		})
+	}, {
+		name: "weight",
+		wireKey: "w",
+		optional: false,
+		codec: require_bigint.bigIntCodec
+	}]
+};
+const RevealMeta = {
+	name: "Reveal",
+	kind: "object",
+	fields: [{
+		name: "sigslot",
+		wireKey: "s",
+		optional: false,
+		codec: new require_object_model.ObjectModelCodec(SigslotCommitMeta)
+	}, {
+		name: "participant",
+		wireKey: "p",
+		optional: false,
+		codec: new require_object_model.ObjectModelCodec(ParticipantMeta)
+	}]
+};
+const StateProofMeta = {
+	name: "StateProof",
+	kind: "object",
+	fields: [
+		{
+			name: "sigCommit",
+			wireKey: "c",
+			optional: false,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "signedWeight",
+			wireKey: "w",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "sigProofs",
+			wireKey: "S",
+			optional: false,
+			codec: new require_object_model.ObjectModelCodec(MerkleArrayProofMeta)
+		},
+		{
+			name: "partProofs",
+			wireKey: "P",
+			optional: false,
+			codec: new require_object_model.ObjectModelCodec(MerkleArrayProofMeta)
+		},
+		{
+			name: "merkleSignatureSaltVersion",
+			wireKey: "v",
+			optional: false,
+			codec: require_number.numberCodec
+		},
+		{
+			name: "reveals",
+			wireKey: "r",
+			optional: false,
+			codec: new require_map.MapCodec(require_bigint.bigIntCodec, new require_object_model.ObjectModelCodec(RevealMeta))
+		},
+		{
+			name: "positionsToReveal",
+			wireKey: "pr",
+			optional: false,
+			codec: require_array.bigIntArrayCodec
+		}
+	]
+};
+const StateProofMessageMeta = {
+	name: "StateProofMessage",
+	kind: "object",
+	fields: [
+		{
+			name: "blockHeadersCommitment",
+			wireKey: "b",
+			optional: false,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "votersCommitment",
+			wireKey: "v",
+			optional: false,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "lnProvenWeight",
+			wireKey: "P",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "firstAttestedRound",
+			wireKey: "f",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "lastAttestedRound",
+			wireKey: "l",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		}
+	]
+};
+const StateProofTransactionFieldsMeta = {
+	name: "StateProofTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "stateProofType",
+			wireKey: "sptype",
+			optional: false,
+			codec: require_number.numberCodec
+		},
+		{
+			name: "stateProof",
+			wireKey: "sp",
+			optional: true,
+			codec: new require_object_model.ObjectModelCodec(StateProofMeta)
+		},
+		{
+			name: "message",
+			wireKey: "spmsg",
+			optional: true,
+			codec: new require_object_model.ObjectModelCodec(StateProofMessageMeta)
+		}
+	]
+};
+const HeartbeatTransactionFieldsMeta = {
+	name: "HeartbeatTransactionFields",
+	kind: "object",
+	fields: [
+		{
+			name: "address",
+			wireKey: "a",
+			optional: false,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "proof",
+			wireKey: "prf",
+			optional: false,
+			codec: new require_object_model.ObjectModelCodec({
+				name: "HeartbeatProof",
+				kind: "object",
+				fields: [
+					{
+						name: "sig",
+						wireKey: "s",
+						optional: false,
+						codec: require_fixed_bytes.fixedBytes64Codec
+					},
+					{
+						name: "pk",
+						wireKey: "p",
+						optional: false,
+						codec: require_fixed_bytes.fixedBytes32Codec
+					},
+					{
+						name: "pk2",
+						wireKey: "p2",
+						optional: false,
+						codec: require_fixed_bytes.fixedBytes32Codec
+					},
+					{
+						name: "pk1Sig",
+						wireKey: "p1s",
+						optional: false,
+						codec: require_fixed_bytes.fixedBytes64Codec
+					},
+					{
+						name: "pk2Sig",
+						wireKey: "p2s",
+						optional: false,
+						codec: require_fixed_bytes.fixedBytes64Codec
+					}
+				]
+			})
+		},
+		{
+			name: "seed",
+			wireKey: "sd",
+			optional: false,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "voteId",
+			wireKey: "vid",
+			optional: false,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "keyDilution",
+			wireKey: "kd",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		}
+	]
+};
+/**
+* Metadata for TransactionParams
+*/
+const TransactionParamsMeta = {
+	name: "TransactionParams",
+	kind: "object",
+	fields: [
+		{
+			name: "type",
+			wireKey: "type",
+			optional: false,
+			codec: new TransactionTypeCodec()
+		},
+		{
+			name: "sender",
+			wireKey: "snd",
+			optional: false,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "fee",
+			wireKey: "fee",
+			optional: true,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "firstValid",
+			wireKey: "fv",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "lastValid",
+			wireKey: "lv",
+			optional: false,
+			codec: require_bigint.bigIntCodec
+		},
+		{
+			name: "genesisHash",
+			wireKey: "gh",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "genesisId",
+			wireKey: "gen",
+			optional: true,
+			codec: require_string.stringCodec
+		},
+		{
+			name: "note",
+			wireKey: "note",
+			optional: true,
+			codec: require_bytes.bytesCodec
+		},
+		{
+			name: "rekeyTo",
+			wireKey: "rekey",
+			optional: true,
+			codec: require_address$1.addressCodec
+		},
+		{
+			name: "lease",
+			wireKey: "lx",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "group",
+			wireKey: "grp",
+			optional: true,
+			codec: require_fixed_bytes.fixedBytes32Codec
+		},
+		{
+			name: "payment",
+			flattened: true,
+			optional: true,
+			codec: new TransactionDataCodec(require_transaction_type.TransactionType.Payment, PaymentTransactionFieldsMeta)
+		},
+		{
+			name: "assetTransfer",
+			flattened: true,
+			optional: true,
+			codec: new TransactionDataCodec(require_transaction_type.TransactionType.AssetTransfer, AssetTransferTransactionFieldsMeta)
+		},
+		{
+			name: "assetFreeze",
+			flattened: true,
+			optional: true,
+			codec: new TransactionDataCodec(require_transaction_type.TransactionType.AssetFreeze, AssetFreezeTransactionFieldsMeta)
+		},
+		{
+			name: "keyRegistration",
+			flattened: true,
+			optional: true,
+			codec: new TransactionDataCodec(require_transaction_type.TransactionType.KeyRegistration, KeyRegistrationTransactionFieldsMeta)
+		},
+		{
+			name: "assetConfig",
+			flattened: true,
+			optional: true,
+			codec: new AssetConfigDataCodec()
+		},
+		{
+			name: "heartbeat",
+			wireKey: "hb",
+			optional: true,
+			codec: new require_object_model.ObjectModelCodec(HeartbeatTransactionFieldsMeta)
+		},
+		{
+			name: "appCall",
+			flattened: true,
+			optional: true,
+			codec: new AppCallDataCodec()
+		},
+		{
+			name: "stateProof",
+			flattened: true,
+			optional: true,
+			codec: new TransactionDataCodec(require_transaction_type.TransactionType.StateProof, StateProofTransactionFieldsMeta)
+		}
+	]
+};
+const transactionParamsCodec = new require_object_model.ObjectModelCodec(TransactionParamsMeta);
+
+//#endregion
+exports.TransactionParamsMeta = TransactionParamsMeta;
+exports.transactionParamsCodec = transactionParamsCodec;
+//# sourceMappingURL=transaction-meta.js.map