beancount 0.1.0 → 0.2.0

package/build/src/classes/nodes/Price.d.mts

@@ -0,0 +1,32 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { FormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents a Price node that records the price of a commodity.
+ * Price directives establish the exchange rate between a commodity and a currency.
+ */
+export declare class Price extends DatedNode {
+    /** @inheritdoc */
+    type: "price";
+    /** The commodity being priced */
+    commodity: string;
+    /** The currency the price is expressed in */
+    currency: string;
+    /** The price amount */
+    amount: string;
+    /**
+     * Gets the formatted price string (amount + currency).
+     * @returns The formatted price string
+     */
+    get price(): string | undefined;
+    /**
+     * Creates a Price instance from a generic parse result.
+     * @param genericParseResult - The parsed price node data
+     * @returns A new Price instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Price;
+    /** @inheritdoc */
+    toString(): string;
+    /** @inheritdoc */
+    toFormattedString(formatOptions?: FormatOptions): string;
+}

package/build/src/classes/nodes/Price.mjs

@@ -0,0 +1,57 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { formatPrice } from '../../utils/formatPrice.mjs';
+import { defaultFormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents a Price node that records the price of a commodity.
+ * Price directives establish the exchange rate between a commodity and a currency.
+ */
+export class Price extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'price';
+    }
+    /**
+     * Gets the formatted price string (amount + currency).
+     * @returns The formatted price string
+     */
+    get price() {
+        return formatPrice(this.amount, this.currency);
+    }
+    /**
+     * Creates a Price instance from a generic parse result.
+     * @param genericParseResult - The parsed price node data
+     * @returns A new Price instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [commodity, amount, currency] = simpleParseLine(genericParseResult.header);
+        return new Price({
+            ...genericParseResult.props,
+            commodity,
+            currency,
+            amount,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    /** @inheritdoc */
+    toFormattedString(formatOptions = defaultFormatOptions) {
+        const parts = [this.getDateTypePrefix(), this.commodity];
+        const paddingLength = formatOptions.currencyColumn -
+            parts.join(' ').length -
+            this.amount.length -
+            2 - // indent
+            2; // spacing
+        if (paddingLength > 0) {
+            parts.push(' '.repeat(paddingLength));
+        }
+        parts.push(this.amount, `${this.currency}${this.getMetaDataString()}`);
+        return parts.join(' ');
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Price);

package/build/src/classes/nodes/Pushtag.d.mts

@@ -0,0 +1,21 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node } from '../Node.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+/**
+ * Represents a Pushtag node that pushes a tag onto the tag stack.
+ * Subsequent transactions will automatically inherit this tag until it's popped.
+ */
+export declare class Pushtag extends Node {
+    /** @inheritdoc */
+    type: "pushtag";
+    /** The tag being pushed onto the stack */
+    tag: Tag;
+    /**
+     * Creates a Pushtag instance from a generic parse result.
+     * @param genericParseResult - The parsed pushtag node data
+     * @returns A new Pushtag instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Pushtag;
+    /** @inheritdoc */
+    toString(): string;
+}

package/build/src/classes/nodes/Pushtag.mjs

@@ -0,0 +1,34 @@
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { assertNodeConstructor, Node } from '../Node.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+/**
+ * Represents a Pushtag node that pushes a tag onto the tag stack.
+ * Subsequent transactions will automatically inherit this tag until it's popped.
+ */
+export class Pushtag extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'pushtag';
+    }
+    /**
+     * Creates a Pushtag instance from a generic parse result.
+     * @param genericParseResult - The parsed pushtag node data
+     * @returns A new Pushtag instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [tagContent] = simpleParseLine(genericParseResult.header);
+        return new Pushtag({
+            tag: new Tag({
+                content: tagContent.trim().replace(/^#/, ''),
+                fromStack: true,
+            }),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.type} #${this.tag.content}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Pushtag);

package/build/src/classes/nodes/Query.d.mts

@@ -0,0 +1,22 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Query node that defines a named SQL query.
+ * Query directives allow defining reusable queries in the Beancount file.
+ */
+export declare class Query extends DatedNode {
+    /** @inheritdoc */
+    type: "query";
+    /** The name of the query */
+    name: string;
+    /** The SQL query contents */
+    sqlContents: string;
+    /**
+     * Creates a Query instance from a generic parse result.
+     * @param genericParseResult - The parsed query node data
+     * @returns A new Query instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Query;
+    /** @inheritdoc */
+    toString(): string;
+}

package/build/src/classes/nodes/Query.mjs

@@ -0,0 +1,34 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { parseString } from '../Value.mjs';
+/**
+ * Represents a Query node that defines a named SQL query.
+ * Query directives allow defining reusable queries in the Beancount file.
+ */
+export class Query extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'query';
+    }
+    /**
+     * Creates a Query instance from a generic parse result.
+     * @param genericParseResult - The parsed query node data
+     * @returns A new Query instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [name, sqlContents] = stringAwareParseLine(genericParseResult.header);
+        return new Query({
+            ...genericParseResult.props,
+            name: parseString(name),
+            sqlContents: parseString(sqlContents).trim(),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} "${this.name}" "${this.sqlContents}"${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Query);

package/build/src/classes/nodes/Transaction/Posting.d.mts

@@ -0,0 +1,59 @@
+import { FormatOptions } from '../../ParseResult.mjs';
+/**
+ * Represents a single posting (account movement) within a transaction.
+ * Each posting records an amount moving to/from an account.
+ */
+export declare class Posting {
+    /** Optional posting flag (e.g., '*' for cleared) */
+    flag?: string;
+    /** The account name for this posting */
+    account: string;
+    /** The amount as a string (may be omitted for auto-calculated postings) */
+    amount?: string;
+    /** The currency code for the amount */
+    currency?: string;
+    /** Optional cost specification (e.g., for currency conversions) */
+    cost?: string;
+    /** Currency for the price annotation */
+    priceCurrency?: string;
+    /** Amount for the price annotation */
+    priceAmount?: string;
+    /** Optional comment for this posting */
+    comment?: string;
+    /** When a cost is given, defines the amount of at signs (1 for unit price, 2 for total price) */
+    atSigns?: number;
+    /**
+     * Creates a new Posting instance.
+     * @param obj - Object containing posting properties
+     */
+    constructor(obj: Record<string, unknown>);
+    /**
+     * Parses a posting line string into a Posting instance.
+     * Expected format: [Flag] Account [Amount Currency] [{Cost}] [@ PriceAmount PriceCurrency] [; Comment]
+     *
+     * @param unparsedline - The posting line string to parse
+     * @returns A new Posting instance
+     * @throws {Error} If the posting line cannot be parsed
+     */
+    static fromString(unparsedline: string): Posting;
+    /**
+     * Gets the formatted price string combining amount, currency, cost, and price annotation.
+     * @returns The formatted price string, or undefined if no price components exist
+     */
+    get price(): string | undefined;
+    /**
+     * Converts this posting to a string representation.
+     * Delegates to toFormattedString with zero currency column alignment.
+     *
+     * @returns The string representation of this posting
+     */
+    toString(): string;
+    /**
+     * Converts this posting to a formatted string with aligned currency column.
+     * Adds padding before the price to align at the specified column.
+     *
+     * @param formatOptions - Formatting options including currency column position
+     * @returns The formatted string representation of this posting
+     */
+    toFormattedString(formatOptions?: FormatOptions): string;
+}

package/build/src/classes/nodes/Transaction/Posting.mjs

@@ -0,0 +1,97 @@
+import { currencyPattern } from '../../../patterns.mjs';
+import { formatPrice } from '../../../utils/formatPrice.mjs';
+import { defaultFormatOptions } from '../../ParseResult.mjs';
+/**
+ * Represents a single posting (account movement) within a transaction.
+ * Each posting records an amount moving to/from an account.
+ */
+export class Posting {
+    /**
+     * Creates a new Posting instance.
+     * @param obj - Object containing posting properties
+     */
+    constructor(obj) {
+        Object.assign(this, obj);
+    }
+    /**
+     * Parses a posting line string into a Posting instance.
+     * Expected format: [Flag] Account [Amount Currency] [{Cost}] [@ PriceAmount PriceCurrency] [; Comment]
+     *
+     * @param unparsedline - The posting line string to parse
+     * @returns A new Posting instance
+     * @throws {Error} If the posting line cannot be parsed
+     */
+    static fromString(unparsedline) {
+        // [Flag] Account Amount [Currency] [{Cost}] [@ Price]
+        const flagPattern = `([^ ]) +`;
+        const accountPattern = `([^ ]*)`;
+        const amountPattern = `([^A-Z;]*)`;
+        const costPattern = `{(.*)}`;
+        const pricePattern = `+(@|@@) +(?:(\\d+\\.?\\d*) ${currencyPattern})`;
+        const amountCurrenyCostPattern = `${amountPattern}(?: +${currencyPattern})?(?: +${costPattern})?(?: ${pricePattern})?`;
+        const commentPattern = `( *;.*)?`;
+        const pattern = `^(?:${flagPattern})?${accountPattern}(?: +${amountCurrenyCostPattern})?${commentPattern}$`;
+        const matches = RegExp(pattern).exec(unparsedline);
+        if (!matches) {
+            throw new Error(`Could not parse posting: ${unparsedline}`);
+        }
+        const [, flag, account, amount, currency, cost, atSigns, priceAmount, priceCurrency, comment,] = matches;
+        return new Posting({
+            flag: flag,
+            account: account?.trim(),
+            amount: amount?.trim().length > 0 ? amount.trim() : undefined,
+            currency: currency?.trim(),
+            cost: cost?.trim(),
+            priceAmount: priceAmount?.trim(),
+            priceCurrency: priceCurrency?.trim(),
+            atSigns: atSigns ? atSigns.length : undefined,
+            comment: comment?.replace(/^ *;/, '').trim(),
+        });
+    }
+    /**
+     * Gets the formatted price string combining amount, currency, cost, and price annotation.
+     * @returns The formatted price string, or undefined if no price components exist
+     */
+    get price() {
+        return formatPrice(this.amount, this.currency, this.cost, this.priceAmount, this.priceCurrency, this.atSigns);
+    }
+    /**
+     * Converts this posting to a string representation.
+     * Delegates to toFormattedString with zero currency column alignment.
+     *
+     * @returns The string representation of this posting
+     */
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    /**
+     * Converts this posting to a formatted string with aligned currency column.
+     * Adds padding before the price to align at the specified column.
+     *
+     * @param formatOptions - Formatting options including currency column position
+     * @returns The formatted string representation of this posting
+     */
+    toFormattedString(formatOptions = defaultFormatOptions) {
+        const parts = [];
+        if (this.flag !== undefined) {
+            parts.push(this.flag);
+        }
+        parts.push(this.account);
+        if (this.price !== undefined) {
+            const paddingLength = formatOptions.currencyColumn -
+                parts.join(' ').length -
+                this.amount.length -
+                2 - // indent
+                2 - // spacing
+                2; // not sure what this is for
+            if (paddingLength > 0) {
+                parts.push(' '.repeat(paddingLength));
+            }
+            parts.push(this.price);
+        }
+        if (this.comment !== undefined) {
+            parts.push(';', this.comment);
+        }
+        return parts.join(' ');
+    }
+}

package/build/src/classes/nodes/Transaction/Tag.d.mts

@@ -0,0 +1,28 @@
+/**
+ * Represents a tag associated with a transaction.
+ * Tags can be specified inline in the transaction or inherited from a tag stack (pushtag/poptag).
+ */
+export declare class Tag {
+    /** The tag name/content (without the '#' prefix) */
+    content: string;
+    /** Whether this tag comes from the tag stack (pushtag) or is inline */
+    fromStack: boolean;
+    /**
+     * Creates a new Tag instance.
+     * @param obj - Object containing tag content and source information
+     * @param obj.content - The tag name/content
+     * @param obj.fromStack - Whether this tag is from the tag stack
+     */
+    constructor(obj: {
+        content: string;
+        fromStack: boolean;
+    });
+    /**
+     * Converts this tag to its string representation.
+     * Tags from the stack return an empty string (they're implicit),
+     * while inline tags return '#tagname' format.
+     *
+     * @returns The tag string with '#' prefix, or empty string if from stack
+     */
+    toString(): string;
+}

package/build/src/classes/nodes/Transaction/Tag.mjs

@@ -0,0 +1,28 @@
+/**
+ * Represents a tag associated with a transaction.
+ * Tags can be specified inline in the transaction or inherited from a tag stack (pushtag/poptag).
+ */
+export class Tag {
+    /**
+     * Creates a new Tag instance.
+     * @param obj - Object containing tag content and source information
+     * @param obj.content - The tag name/content
+     * @param obj.fromStack - Whether this tag is from the tag stack
+     */
+    constructor(obj) {
+        Object.assign(this, obj);
+    }
+    /**
+     * Converts this tag to its string representation.
+     * Tags from the stack return an empty string (they're implicit),
+     * while inline tags return '#tagname' format.
+     *
+     * @returns The tag string with '#' prefix, or empty string if from stack
+     */
+    toString() {
+        if (this.fromStack) {
+            return '';
+        }
+        return `#${this.content}`;
+    }
+}

package/build/src/classes/nodes/Transaction/index.d.mts

@@ -0,0 +1,70 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type { GenericParseResultTransaction } from '../../../genericParse.mjs';
+import { DatedNode } from '../../DatedNode.mjs';
+import { Posting } from './Posting.mjs';
+import { Tag } from './Tag.mjs';
+import { FormatOptions } from '../../ParseResult.mjs';
+export interface PostingComment {
+    order: number;
+    comment: string;
+}
+/**
+ * Represents a Beancount transaction node.
+ * Transactions record financial movements between accounts with postings.
+ */
+export declare class Transaction extends DatedNode {
+    /** @inheritdoc */
+    type: "transaction";
+    /** The payee of the transaction */
+    payee: string;
+    /** Optional narration/description of the transaction */
+    narration?: string;
+    /** Optional transaction flag (e.g., '*' for cleared, '!' for pending) */
+    flag?: string;
+    /** Array of postings (account movements) in this transaction */
+    postings: Posting[];
+    /** Array of comments under this transaction (mixed in with the postings) */
+    postingComments: PostingComment[];
+    /** Set of link identifiers associated with this transaction */
+    links: Set<string>;
+    /** Array of tags associated with this transaction (from inline tags and tag stack) */
+    tags: Tag[];
+    /**
+     * @inheritdoc
+     */
+    constructor(obj: {
+        date: string | Temporal.PlainDate;
+        [key: string]: unknown;
+    });
+    /**
+     * Creates a Transaction instance from a generic parse result.
+     * Parses payee, narration, links, tags, postings, and metadata.
+     *
+     * @param genericParseResult - The parsed transaction data
+     * @returns A new Transaction instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultTransaction): Transaction;
+    /** @inheritdoc */
+    toString(): string;
+    /** @inheritdoc */
+    toFormattedString(formatOptions?: FormatOptions): string;
+    /**
+     * Converts this transaction to a JSON-serializable object.
+     * Ensures the links Set is properly serialized as an array.
+     *
+     * @returns A JSON-serializable representation of this transaction
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Transforms JSON data before creating a Transaction instance.
+     * Deserializes transaction-specific properties including postings, tags, links, and metadata.
+     *
+     * @param json - The JSON data to transform
+     * @returns The transformed data with:
+     *   - postings converted to Posting instances
+     *   - tags converted to Tag instances
+     *   - links converted from array to Set<string>
+     *   - metadata values converted to Value instances
+     */
+    protected parseJSONData(json: Record<string, unknown>): Record<string, unknown>;
+}

package/build/src/classes/nodes/Transaction/index.mjs

@@ -0,0 +1,193 @@
+import { assertNodeConstructor } from '../../Node.mjs';
+import { DatedNode } from '../../DatedNode.mjs';
+import { stringAwareParseLine } from '../../../utils/stringAwareParseLine.mjs';
+import { parseString, Value } from '../../Value.mjs';
+import { parseMetadata } from '../../../utils/parseMetadata.mjs';
+import { Posting } from './Posting.mjs';
+import { Tag } from './Tag.mjs';
+import { defaultFormatOptions } from '../../ParseResult.mjs';
+/**
+ * Valid Beancount account type prefixes.
+ * @internal
+ */
+const AccountTypes = ['Assets', 'Liabilities', 'Equity', 'Income', 'Expenses'];
+/**
+ * Parses a string to extract narration/payee, links, and tags.
+ * Links are prefixed with '^' and tags with '#'.
+ *
+ * @param input - The string to parse (may contain narration in quotes, links, and tags)
+ * @returns An object containing extracted links, tags, and the remaining string (narration/payee)
+ * @internal
+ */
+const getStringLinksAndTags = (input) => {
+    let links = new Set();
+    let tags = [];
+    // default if no narration
+    let strRemaining = '';
+    let linksAndTags = input;
+    // check for narration
+    const match = /^(".*")(.*)/.exec(input);
+    if (match) {
+        // strRemaining = narration
+        strRemaining = match[1];
+        linksAndTags = match[2];
+    }
+    const linksMatch = linksAndTags.matchAll(/\^([\w-_.]*)/g);
+    if (linksMatch) {
+        links = new Set(linksMatch.map((m) => m[1]));
+    }
+    const tagsMatch = linksAndTags.matchAll(/#([\w-_.]*)/g);
+    if (tagsMatch) {
+        tags = tagsMatch
+            .map((m) => new Tag({ content: m[1], fromStack: false }))
+            .toArray();
+    }
+    return { links, tags, string: strRemaining };
+};
+/**
+ * Represents a Beancount transaction node.
+ * Transactions record financial movements between accounts with postings.
+ */
+export class Transaction extends DatedNode {
+    /**
+     * @inheritdoc
+     */
+    constructor(obj) {
+        /*
+         * This constructor exists to provide a default value for some values.
+         * Class field initializers (e.g., `postingComments = []`) run after
+         * `super()` returns, which would overwrite values set by `Object.assign`
+         * in the parent constructor.
+         */
+        super(obj);
+        /** @inheritdoc */
+        this.type = 'transaction';
+        this.postingComments ??= [];
+        this.postings ??= [];
+        this.links ??= new Set();
+        this.tags ??= [];
+    }
+    /**
+     * Creates a Transaction instance from a generic parse result.
+     * Parses payee, narration, links, tags, postings, and metadata.
+     *
+     * @param genericParseResult - The parsed transaction data
+     * @returns A new Transaction instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        // eslint-disable-next-line prefer-const
+        let [payee, ...rest] = stringAwareParseLine(genericParseResult.header);
+        let links = new Set();
+        let tags = [];
+        let narration;
+        if (rest.length === 0) {
+            // no narration
+            const payeeParsed = getStringLinksAndTags(payee);
+            payee = payeeParsed.string;
+            links = payeeParsed.links;
+            tags = payeeParsed.tags;
+        }
+        else {
+            const payeeParsed = getStringLinksAndTags(rest.join(' '));
+            narration = payeeParsed.string;
+            links = payeeParsed.links;
+            tags = payeeParsed.tags;
+        }
+        const unparsedPostings = [];
+        const unparsedMetadata = [];
+        const postingComments = [];
+        genericParseResult.body.forEach((line) => {
+            //                           V remove flag,       V get account type
+            const accountType = line.replace(/^[^ ] /, '').split(':')[0];
+            if (AccountTypes.includes(accountType)) {
+                unparsedPostings.push(line);
+            }
+            else if (line.startsWith(';')) {
+                postingComments.push({
+                    comment: line,
+                    order: unparsedPostings.length + postingComments.length,
+                });
+            }
+            else {
+                unparsedMetadata.push(line);
+            }
+        });
+        const postings = unparsedPostings.map((p) => Posting.fromString(p));
+        const metadata = parseMetadata(unparsedMetadata);
+        return new Transaction({
+            ...genericParseResult.props,
+            payee: parseString(payee),
+            narration: narration ? parseString(narration) : undefined,
+            postings,
+            postingComments,
+            metadata,
+            links,
+            tags,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    /** @inheritdoc */
+    toFormattedString(formatOptions = defaultFormatOptions) {
+        const firstLine = [
+            this.date.toJSON(),
+            this.flag ?? 'txn',
+            `"${this.payee}"`,
+        ];
+        if (this.narration !== undefined) {
+            firstLine.push(`"${this.narration}"`);
+        }
+        firstLine.push(...this.links.values().map((l) => `^${l}`));
+        firstLine.push(...this.tags.map((t) => t.toString()));
+        const lines = [firstLine.join(' ') + this.getMetaDataString()];
+        const postingLines = this.postings.map((p) => `  ${p.toFormattedString(formatOptions)}`);
+        this.postingComments.forEach((comment) => {
+            postingLines.splice(comment.order, 0, `  ${comment.comment}`);
+        });
+        lines.push(...postingLines);
+        return lines.join('\n');
+    }
+    /**
+     * Converts this transaction to a JSON-serializable object.
+     * Ensures the links Set is properly serialized as an array.
+     *
+     * @returns A JSON-serializable representation of this transaction
+     */
+    toJSON() {
+        return {
+            ...this,
+            links: Array.from(this.links),
+        };
+    }
+    /**
+     * Transforms JSON data before creating a Transaction instance.
+     * Deserializes transaction-specific properties including postings, tags, links, and metadata.
+     *
+     * @param json - The JSON data to transform
+     * @returns The transformed data with:
+     *   - postings converted to Posting instances
+     *   - tags converted to Tag instances
+     *   - links converted from array to Set<string>
+     *   - metadata values converted to Value instances
+     */
+    parseJSONData(json) {
+        const { postings, postingComments, tags, links, metadata, ...rest } = json;
+        return {
+            ...rest,
+            postings: postings?.map((p) => new Posting(p)),
+            postingComments: postingComments ?? [],
+            tags: tags?.map((t) => new Tag(t)),
+            links: links ? new Set(links) : new Set(),
+            metadata: metadata
+                ? Object.fromEntries(Object.entries(metadata).map(([key, val]) => [
+                    key,
+                    new Value(val),
+                ]))
+                : undefined,
+        };
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Transaction);