@leet4tari/ootle-ts-bindings 1.23.2

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, The Tari Developer Community
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,6 @@
+# Tari Ootle Typescript bindings
+
+## Overview
+
+This repository contains the TypeScript bindings for the Tari Ootle library. The bindings are generated from rust types
+using [ts_rs](https://docs.rs/ts-rs/latest/ts_rs/).

package/dist/base-node-client.d.ts

@@ -0,0 +1 @@
+export * from "./types/base-node-client/BaseLayerValidatorNode";

package/dist/base-node-client.js

@@ -0,0 +1,3 @@
+//   Copyright 2026 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+export * from "./types/base-node-client/BaseLayerValidatorNode";

package/dist/helpers/BigAmount.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Class that represents an arbitrary precision value.
+ * This encodes to JSON using the "special" syntax to coerce a value to an Amount.
+ */
+export declare class BigAmount {
+    private inner;
+    constructor(amount: bigint | string | number);
+    static from(amount: bigint | string | number): BigAmount;
+    get value(): BigInt;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/helpers/BigAmount.js

@@ -0,0 +1,27 @@
+/*
+ * //   Copyright 2025 The Tari Project
+ * //   SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Class that represents an arbitrary precision value.
+ * This encodes to JSON using the "special" syntax to coerce a value to an Amount.
+ */
+export class BigAmount {
+    inner;
+    constructor(amount) {
+        this.inner = BigInt(amount);
+    }
+    static from(amount) {
+        return new BigAmount(amount);
+    }
+    get value() {
+        return this.inner;
+    }
+    toString() {
+        return this.inner.toString();
+    }
+    toJSON() {
+        // Uses the special syntax supported by the wallet/indexer to coerce the value to an Amount
+        return `Amount(${this.toString()})`;
+    }
+}

package/dist/helpers/NetworkByte.d.ts

@@ -0,0 +1,9 @@
+export declare enum NetworkByte {
+    MainNet = 0,
+    StageNet = 1,
+    NextNet = 2,
+    LocalNet = 16,
+    Igor = 36,
+    Esmeralda = 38
+}
+export declare function getNetworkName(network: NetworkByte): string;

package/dist/helpers/NetworkByte.js

@@ -0,0 +1,31 @@
+/*
+ * //   Copyright 2025 The Tari Project
+ * //   SPDX-License-Identifier: BSD-3-Clause
+ */
+export var NetworkByte;
+(function (NetworkByte) {
+    NetworkByte[NetworkByte["MainNet"] = 0] = "MainNet";
+    NetworkByte[NetworkByte["StageNet"] = 1] = "StageNet";
+    NetworkByte[NetworkByte["NextNet"] = 2] = "NextNet";
+    NetworkByte[NetworkByte["LocalNet"] = 16] = "LocalNet";
+    NetworkByte[NetworkByte["Igor"] = 36] = "Igor";
+    NetworkByte[NetworkByte["Esmeralda"] = 38] = "Esmeralda";
+})(NetworkByte || (NetworkByte = {}));
+export function getNetworkName(network) {
+    switch (network) {
+        case NetworkByte.MainNet:
+            return "mainnet";
+        case NetworkByte.StageNet:
+            return "stagenet";
+        case NetworkByte.NextNet:
+            return "nextnet";
+        case NetworkByte.LocalNet:
+            return "localnet";
+        case NetworkByte.Igor:
+            return "igor";
+        case NetworkByte.Esmeralda:
+            return "esmeralda";
+        default:
+            throw new Error(`Unknown network byte: ${network}`);
+    }
+}

package/dist/helpers/consts.d.ts

@@ -0,0 +1,5 @@
+export declare const ACCOUNT_TEMPLATE_ADDRESS = "0000000000000000000000000000000000000000000000000000000000000000";
+export declare const TESTNET_NFT_FAUCET_ADDRESS = "component_0000000000000000000000000000000000000000000000000000000000000001";
+export declare const TESTNET_XTR_FAUCET_ADDRESS = "component_0102030000000000000000000000000000000000000000000000000000000000";
+export declare const XTR_RESOURCE_ADDRESS = "resource_0101010101010101010101010101010101010101010101010101010101010101";
+export declare const XTR = "resource_0101010101010101010101010101010101010101010101010101010101010101";

package/dist/helpers/consts.js

@@ -0,0 +1,9 @@
+/*
+ * //   Copyright 2025 The Tari Project
+ * //   SPDX-License-Identifier: BSD-3-Clause
+ */
+export const ACCOUNT_TEMPLATE_ADDRESS = "0000000000000000000000000000000000000000000000000000000000000000";
+export const TESTNET_NFT_FAUCET_ADDRESS = "component_0000000000000000000000000000000000000000000000000000000000000001";
+export const TESTNET_XTR_FAUCET_ADDRESS = "component_0102030000000000000000000000000000000000000000000000000000000000";
+export const XTR_RESOURCE_ADDRESS = "resource_0101010101010101010101010101010101010101010101010101010101010101";
+export const XTR = XTR_RESOURCE_ADDRESS;

package/dist/helpers/enum.d.ts

@@ -0,0 +1 @@
+export declare function matchesTypeEnum<T extends Object>(enumObject: T | null, value: T | null): boolean;

package/dist/helpers/enum.js

@@ -0,0 +1,22 @@
+//   Copyright 2025 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+export function matchesTypeEnum(enumObject, value) {
+    if (enumObject === null && value === null) {
+        return true;
+    }
+    if (enumObject === null || value === null) {
+        return false;
+    }
+    const keys = Object.keys(enumObject);
+    if (keys.length !== 1) {
+        throw new Error("Enum object must have exactly one key");
+    }
+    const key = keys[0];
+    if (!(key in value)) {
+        return false;
+    }
+    // check the value
+    const enumValue = enumObject[key];
+    const valueValue = value[key];
+    return enumValue === valueValue;
+}

package/dist/helpers/helpers.d.ts

@@ -0,0 +1,13 @@
+import { JrpcPermission } from "../types/JrpcPermission";
+import { RejectReason } from "../types/RejectReason";
+import { SubstateDiff } from "../types/SubstateDiff";
+import { SubstateId } from "../types/SubstateId";
+import { TransactionResult } from "../types/TransactionResult";
+export declare function substateIdToString(substateId: SubstateId | string | null | undefined): string;
+export declare function stringToSubstateId(substateId: string): SubstateId;
+export declare function shortenSubstateId(substateId: SubstateId | string | null | undefined, start?: number, end?: number): string;
+export declare function shortenString(string: string, start?: number, end?: number): string;
+export declare function rejectReasonToString(reason: RejectReason | null): string;
+export declare function getSubstateDiffFromTransactionResult(result: TransactionResult): SubstateDiff | null;
+export declare function getRejectReasonFromTransactionResult(result: TransactionResult): RejectReason | null;
+export declare function jrpcPermissionToString(jrpcPermission: JrpcPermission): string;

package/dist/helpers/helpers.js

@@ -0,0 +1,194 @@
+//   Copyright 2023 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+// TODO: this function should be deprecated
+export function substateIdToString(substateId) {
+    if (substateId === null || substateId === undefined) {
+        return "";
+    }
+    if (typeof substateId === "string") {
+        return substateId;
+    }
+    if (typeof substateId !== "object") {
+        throw new Error(`Cannot convert: ${JSON.stringify(substateId)} to string`);
+    }
+    // if ("Component" in substateId) {
+    //   return substateId.Component;
+    // }
+    // if ("Resource" in substateId) {
+    //   return substateId.Resource;
+    // }
+    // if ("Vault" in substateId) {
+    //   return substateId.Vault;
+    // }
+    // if ("ClaimedOutputTombstone" in substateId) {
+    //   return substateId.ClaimedOutputTombstone;
+    // }
+    // if ("NonFungible" in substateId) {
+    //   const nft = substateId.NonFungible;
+    //   const key = Object.keys(nft.id)[0];
+    //   const type = key.toLowerCase();
+    //   return `nft_${nft.resource_address}_${type}_${nft.id[key]}`;
+    // }
+    // if ("TransactionReceipt" in substateId) {
+    //   return substateId.TransactionReceipt;
+    // }
+    // if ("ValidatorFeePool" in substateId) {
+    //   return substateId.ValidatorFeePool;
+    // }
+    console.error("Unknown substate id", substateId);
+    return substateId;
+}
+// TODO: this function should be deprecated
+export function stringToSubstateId(substateId) {
+    const parts = splitOnce(substateId, "_");
+    if (!parts) {
+        throw new Error(`Invalid substate id: ${substateId}`);
+    }
+    return substateId;
+    // const [prefix, rest] = parts;
+    //
+    // switch (prefix) {
+    //   case "component":
+    //     return { Component: rest };
+    //   case "resource":
+    //     return { Resource: rest };
+    //   case "vault":
+    //     return { Vault: rest };
+    //   case "tombstone":
+    //     return { ClaimedOutputTombstone: rest };
+    //   case "txreceipt":
+    //     return { TransactionReceipt: rest };
+    //   case "vnfp":
+    //     return { ValidatorFeePool: rest };
+    //   case "nft":
+    //     const nftParts = rest.split("_", 3);
+    //     if (nftParts.length != 3) {
+    //       throw new Error(`Invalid NFT substate id: ${substateId}`);
+    //     }
+    //
+    //     const [resourceAddress, type, id] = nftParts;
+    //
+    //     return {
+    //       NonFungible: {
+    //         resource_address: resourceAddress,
+    //         id: { [type]: id } as NonFungibleId,
+    //       },
+    //     };
+    //   case "template":
+    //     return { Template: rest };
+    //   case "utxo":
+    //     const utxoParts = rest.split("_", 2);
+    //     if (utxoParts.length != 2) {
+    //       throw new Error(`Invalid UTXO substate id: ${substateId}`);
+    //     }
+    //
+    //     return { Utxo: { resource_address: utxoParts[0], id: utxoParts[1] } };
+    //
+    //   default:
+    //     throw new Error(`Unknown substate id: ${substateId}`);
+    // }
+}
+export function shortenSubstateId(substateId, start = 4, end = 4) {
+    if (substateId === null || substateId === undefined) {
+        return "";
+    }
+    const string = substateIdToString(substateId);
+    const parts = string.split("_", 2);
+    if (parts.length < 2) {
+        return string;
+    }
+    return parts[0] + "_" + shortenString(parts[1], start, end);
+}
+export function shortenString(string, start = 8, end = 8) {
+    return string.substring(0, start) + "..." + string.slice(-end);
+}
+export function rejectReasonToString(reason) {
+    if (reason === null) {
+        return "";
+    }
+    if (typeof reason === "string") {
+        return reason;
+    }
+    if ("ShardsNotPledged" in reason) {
+        return `ShardsNotPledged: ${reason.ShardsNotPledged}`;
+    }
+    if ("ExecutionFailure" in reason) {
+        return `ExecutionFailure: ${reason.ExecutionFailure}`;
+    }
+    if ("ShardPledgedToAnotherPayload" in reason) {
+        return `ShardPledgedToAnotherPayload: ${reason.ShardPledgedToAnotherPayload}`;
+    }
+    if ("ShardRejected" in reason) {
+        return `ShardRejected: ${reason.ShardRejected}`;
+    }
+    if ("InsufficientFeesPaid" in reason) {
+        return `InsufficientFeesPaid: ${reason.InsufficientFeesPaid}`;
+    }
+    if ("ForeignShardGroupDecidedToAbort" in reason) {
+        const r = reason.ForeignShardGroupDecidedToAbort;
+        return `ForeignShardGroupDecidedToAbort: ${r.start_shard}-${r.end_shard}, ${r.abort_reason}`;
+    }
+    if ("InvalidTransaction" in reason) {
+        return `InvalidTransaction: ${reason.InvalidTransaction}`;
+    }
+    if ("ExecutionFailure" in reason) {
+        return `ExecutionFailure: ${reason.ExecutionFailure}`;
+    }
+    if ("OneOrMoreInputsNotFound" in reason) {
+        return `OneOrMoreInputsNotFound: ${reason.OneOrMoreInputsNotFound}`;
+    }
+    if ("FailedToLockInputs" in reason) {
+        return `FailedToLockInputs: ${reason.FailedToLockInputs}`;
+    }
+    if ("FailedToLockOutputs" in reason) {
+        return `FailedToLockOutputs: ${reason.FailedToLockOutputs}`;
+    }
+    console.error("Unknown reason", reason);
+    return JSON.stringify(reason);
+}
+export function getSubstateDiffFromTransactionResult(result) {
+    if ("Accept" in result) {
+        return result.Accept;
+    }
+    if ("AcceptFeeRejectRest" in result) {
+        return result.AcceptFeeRejectRest[0];
+    }
+    return null;
+}
+export function getRejectReasonFromTransactionResult(result) {
+    if ("Reject" in result) {
+        return result.Reject;
+    }
+    if ("AcceptFeeRejectRest" in result) {
+        return result.AcceptFeeRejectRest[1];
+    }
+    return null;
+}
+export function jrpcPermissionToString(jrpcPermission) {
+    if (typeof jrpcPermission === "string") {
+        return jrpcPermission;
+    }
+    if ("NftGetOwnershipProof" in jrpcPermission) {
+        return `NftGetOwnershipProof(${jrpcPermission.NftGetOwnershipProof})`;
+    }
+    if ("AccountBalance" in jrpcPermission) {
+        return `AccountBalance(${substateIdToString(jrpcPermission.AccountBalance)})`;
+    }
+    if ("AccountList" in jrpcPermission) {
+        return `AccountList(${jrpcPermission.AccountList})`;
+    }
+    if ("TransactionSend" in jrpcPermission) {
+        return `TransactionSend(${jrpcPermission.TransactionSend})`;
+    }
+    if ("GetNft" in jrpcPermission) {
+        return `GetNft(${substateIdToString(jrpcPermission.GetNft[0])}, ${jrpcPermission.GetNft[1]})`;
+    }
+    return "Unknown";
+}
+function splitOnce(str, separator) {
+    const index = str.indexOf(separator);
+    if (index === -1) {
+        return null;
+    }
+    return [str.slice(0, index), str.slice(index + 1)];
+}

package/dist/helpers/ootleAddress.d.ts

@@ -0,0 +1,20 @@
+import { OotleAddress } from "../types/OotleAddress";
+import { Network } from "../types/Network";
+export type DecodedOotleAddress = {
+    network: Network;
+    accountPublicKey: string;
+    viewOnlyKey: string;
+    payRef: string | Uint8Array | null;
+};
+export declare enum NetworkHrp {
+    MainNet = "otl_",
+    StageNet = "otl_stg_",
+    NextNet = "otl_nxt_",
+    LocalNet = "otl_loc_",
+    Igor = "otl_igr_",
+    Esmeralda = "otl_esm_"
+}
+export declare function decodeOotleAddressOrNull(address: OotleAddress): DecodedOotleAddress | null;
+export declare function decodeOotleAddress(address: OotleAddress): DecodedOotleAddress;
+export declare function encodeOotleAddress(decoded: DecodedOotleAddress): OotleAddress;
+export declare function validateOotleAddress(address: string): boolean;

package/dist/helpers/ootleAddress.js

@@ -0,0 +1,157 @@
+//   Copyright 2025 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+import { bech32m } from "bech32";
+const PAY_REF_MAX_LENGTH = 64;
+const MAX_LENGTH_LIMIT = 118 + PAY_REF_MAX_LENGTH;
+export var NetworkHrp;
+(function (NetworkHrp) {
+    NetworkHrp["MainNet"] = "otl_";
+    NetworkHrp["StageNet"] = "otl_stg_";
+    NetworkHrp["NextNet"] = "otl_nxt_";
+    NetworkHrp["LocalNet"] = "otl_loc_";
+    NetworkHrp["Igor"] = "otl_igr_";
+    NetworkHrp["Esmeralda"] = "otl_esm_";
+})(NetworkHrp || (NetworkHrp = {}));
+export function decodeOotleAddressOrNull(address) {
+    try {
+        return decodeOotleAddress(address);
+    }
+    catch (e) {
+        console.warn("decodeOotleAddressOrNull: decode error:", e, address);
+        return null;
+    }
+}
+export function decodeOotleAddress(address) {
+    const { prefix, words } = bech32m.decode(address, MAX_LENGTH_LIMIT);
+    const data = bech32m.fromWords(words);
+    if (data.length < 64) {
+        throw new Error(`Invalid Ootle address length: ${data.length}, expected 64`);
+    }
+    const accountPublicKey = buf2hex(data.slice(0, 32));
+    const viewOnlyKey = buf2hex(data.slice(32, 64));
+    const payRefBytes = new Uint8Array(data.slice(64));
+    // If the payRefSlice is utf-8 decodable, use it as payRef, otherwise null
+    let payRef = null;
+    if (payRefBytes.length > 0) {
+        try {
+            payRef = new TextDecoder().decode(payRefBytes);
+        }
+        catch (e) {
+            payRef = payRefBytes;
+        }
+    }
+    let network;
+    switch (prefix) {
+        case NetworkHrp.MainNet:
+            network = "mainnet";
+            break;
+        case NetworkHrp.StageNet:
+            network = "stagenet";
+            break;
+        case NetworkHrp.NextNet:
+            network = "nextnet";
+            break;
+        case NetworkHrp.LocalNet:
+            network = "localnet";
+            break;
+        case NetworkHrp.Igor:
+            network = "igor";
+            break;
+        case NetworkHrp.Esmeralda:
+            network = "esmeralda";
+            break;
+        default:
+            throw new Error("Invalid network prefix in Ootle address");
+    }
+    return {
+        network,
+        accountPublicKey,
+        viewOnlyKey,
+        payRef,
+    };
+}
+export function encodeOotleAddress(decoded) {
+    let networkHrp;
+    switch (decoded.network) {
+        case "mainnet":
+            networkHrp = NetworkHrp.MainNet;
+            break;
+        case "stagenet":
+            networkHrp = NetworkHrp.StageNet;
+            break;
+        case "nextnet":
+            networkHrp = NetworkHrp.NextNet;
+            break;
+        case "localnet":
+            networkHrp = NetworkHrp.LocalNet;
+            break;
+        case "igor":
+            networkHrp = NetworkHrp.Igor;
+            break;
+        case "esmeralda":
+            networkHrp = NetworkHrp.Esmeralda;
+            break;
+        default:
+            throw new Error(`Invalid network: ${decoded.network}`);
+    }
+    if (decoded.accountPublicKey.length !== 64 || decoded.viewOnlyKey.length !== 64) {
+        throw new Error("Public keys must be 32 bytes (64 hex characters) long");
+    }
+    const accountPubKeyBytes = hex2buf(decoded.accountPublicKey);
+    const viewOnlyKeyBytes = hex2buf(decoded.viewOnlyKey);
+    const payRefBytes = decoded.payRef
+        ? typeof decoded.payRef === "string"
+            ? new TextEncoder().encode(decoded.payRef)
+            : decoded.payRef
+        : new Uint8Array();
+    const addressBytes = new Uint8Array(accountPubKeyBytes.length + viewOnlyKeyBytes.length + payRefBytes.length);
+    addressBytes.set(accountPubKeyBytes, 0);
+    addressBytes.set(viewOnlyKeyBytes, accountPubKeyBytes.length);
+    addressBytes.set(payRefBytes, accountPubKeyBytes.length + viewOnlyKeyBytes.length);
+    const words = bech32m.toWords(addressBytes);
+    return bech32m.encode(networkHrp, words, MAX_LENGTH_LIMIT);
+}
+const HEX = /[\da-fA-F]{2}/i;
+function buf2hex(buffer) {
+    return buffer.map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function hex2buf(string) {
+    // Check if Uint8Array.fromHex is available (most modern browsers)
+    const fromHex = Uint8Array.fromHex;
+    if (typeof fromHex === "function") {
+        return fromHex(string);
+    }
+    const stringLength = string.length;
+    if (stringLength % 2 !== 0)
+        throw new SyntaxError("String should be an even number of characters");
+    const maxLength = stringLength / 2;
+    const bytes = new Uint8Array(maxLength);
+    let read = 0;
+    let written = 0;
+    while (written < maxLength) {
+        const hexits = string.slice(read, (read += 2));
+        if (!HEX.exec(hexits))
+            throw new SyntaxError("String should only contain hex characters");
+        bytes[written++] = parseInt(hexits, 16);
+    }
+    return bytes;
+}
+export function validateOotleAddress(address) {
+    if (!address || typeof address !== "string") {
+        return false;
+    }
+    // Trim whitespace for consistent validation
+    const trimmedAddress = address.trim();
+    if (trimmedAddress.length > MAX_LENGTH_LIMIT) {
+        console.debug(`validateOotleAddress: Invalid length ${trimmedAddress.length}, expected ${MAX_LENGTH_LIMIT} for address ${address}`);
+        return false;
+    }
+    try {
+        decodeOotleAddress(trimmedAddress);
+    }
+    catch (e) {
+        console.error("validateOotleAddress: decode error:", e, trimmedAddress);
+        return false;
+    }
+    return true;
+}

package/dist/helpers/tariTypeTag.d.ts

@@ -0,0 +1,15 @@
+export declare enum TariTypeTag {
+    ComponentAddress = 128,
+    Metadata = 129,
+    NonFungibleAddress = 130,
+    ResourceAddress = 131,
+    VaultId = 132,
+    TransactionReceipt = 134,
+    ProofId = 135,
+    ClaimedOutputTombstoneAddress = 136,
+    TemplateAddress = 137,
+    ValidatorNodeFeePool = 138,
+    AllocatedComponentAddress = 139,
+    AllocatedResourceAddress = 140,
+    Utxo = 141
+}

package/dist/helpers/tariTypeTag.js

@@ -0,0 +1,20 @@
+/*
+ * //   Copyright 2025 The Tari Project
+ * //   SPDX-License-Identifier: BSD-3-Clause
+ */
+export var TariTypeTag;
+(function (TariTypeTag) {
+    TariTypeTag[TariTypeTag["ComponentAddress"] = 128] = "ComponentAddress";
+    TariTypeTag[TariTypeTag["Metadata"] = 129] = "Metadata";
+    TariTypeTag[TariTypeTag["NonFungibleAddress"] = 130] = "NonFungibleAddress";
+    TariTypeTag[TariTypeTag["ResourceAddress"] = 131] = "ResourceAddress";
+    TariTypeTag[TariTypeTag["VaultId"] = 132] = "VaultId";
+    TariTypeTag[TariTypeTag["TransactionReceipt"] = 134] = "TransactionReceipt";
+    TariTypeTag[TariTypeTag["ProofId"] = 135] = "ProofId";
+    TariTypeTag[TariTypeTag["ClaimedOutputTombstoneAddress"] = 136] = "ClaimedOutputTombstoneAddress";
+    TariTypeTag[TariTypeTag["TemplateAddress"] = 137] = "TemplateAddress";
+    TariTypeTag[TariTypeTag["ValidatorNodeFeePool"] = 138] = "ValidatorNodeFeePool";
+    TariTypeTag[TariTypeTag["AllocatedComponentAddress"] = 139] = "AllocatedComponentAddress";
+    TariTypeTag[TariTypeTag["AllocatedResourceAddress"] = 140] = "AllocatedResourceAddress";
+    TariTypeTag[TariTypeTag["Utxo"] = 141] = "Utxo";
+})(TariTypeTag || (TariTypeTag = {}));