@tari-project/tarijs-builders 0.6.0 → 0.9.0

package/dist/helpers/index.d.ts

@@ -1,2 +1,2 @@
 export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult } from "./submitTransaction";
-export { fromWorkspace, toWorkspace } from "./workspace";
+export { parseWorkspaceStringKey, NamedArg } from "./workspace";

package/dist/helpers/index.js

@@ -1,2 +1,2 @@
 export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult } from "./submitTransaction";
-export { fromWorkspace, toWorkspace } from "./workspace";
+export { parseWorkspaceStringKey } from "./workspace";

package/dist/helpers/submitTransaction.d.ts

@@ -1,7 +1,9 @@
 import { TariUniverseSigner } from "@tari-project/tari-universe-signer";
 import { TariSigner } from "@tari-project/tari-signer";
-import { Transaction, TransactionResult, DownSubstates, UpSubstates, SubmitTxResult, ReqSubstate, SubmitTransactionRequest } from "@tari-project/tarijs-types";
-export declare function buildTransactionRequest(transaction: Transaction, accountId: number, requiredSubstates: ReqSubstate[], inputRefs?: never[], isDryRun?: boolean, network?: number, isSealSignerAuthorized?: boolean, detectInputsUseUnversioned?: boolean): SubmitTransactionRequest;
+import { TransactionResult, UnsignedTransactionV1 } from "@tari-project/typescript-bindings";
+import { DownSubstates, UpSubstates, SubmitTransactionRequest } from "@tari-project/tarijs-types";
+import { SubmitTxResult } from "@tari-project/tarijs-types/dist/TransactionResult";
+export declare function buildTransactionRequest(transaction: UnsignedTransactionV1, accountId: number, detectInputsUseUnversioned?: boolean): SubmitTransactionRequest;
 export declare function submitAndWaitForTransaction(signer: TariSigner, req: SubmitTransactionRequest): Promise<SubmitTxResult>;
 export declare function waitForTransactionResult(signer: TariSigner | TariUniverseSigner, transactionId: string): Promise<TransactionResult>;
 export declare function getAcceptResultSubstates(txResult: TransactionResult): {

package/dist/helpers/submitTransaction.js

@@ -1,18 +1,9 @@
-import { TransactionStatus, } from "@tari-project/tarijs-types";
-import { getSubstateValueFromUpSubstates, substateIdToString, txResultCheck } from "@tari-project/tarijs-types";
-export function buildTransactionRequest(transaction, accountId, requiredSubstates, inputRefs = [], isDryRun = false, network = 0, isSealSignerAuthorized = true, detectInputsUseUnversioned = true) {
+import { substateIdToString, } from "@tari-project/typescript-bindings";
+import { getSubstateValueFromUpSubstates, TransactionStatus, } from "@tari-project/tarijs-types";
+export function buildTransactionRequest(transaction, accountId, detectInputsUseUnversioned = true) {
     return {
-        network,
+        transaction,
         account_id: accountId,
-        instructions: transaction.instructions,
-        fee_instructions: transaction.feeInstructions,
-        inputs: transaction.inputs,
-        input_refs: inputRefs,
-        required_substates: requiredSubstates,
-        is_dry_run: isDryRun,
-        min_epoch: transaction.minEpoch ?? null,
-        max_epoch: transaction.maxEpoch ?? null,
-        is_seal_signer_authorized: isSealSignerAuthorized,
         detect_inputs_use_unversioned: detectInputsUseUnversioned,
     };
 }
@@ -62,21 +53,26 @@ export async function waitForTransactionResult(signer, transactionId) {
             throw new Error(`Transaction rejected: ${JSON.stringify(resp.result)}`);
         }
         if (FINALIZED_STATUSES.includes(resp.status)) {
-            return resp;
+            return resp.result?.result;
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
 export function getAcceptResultSubstates(txResult) {
-    const result = txResult.result?.result;
-    if (result && txResultCheck.isAcceptFeeRejectRest(result)) {
+    if ("Accept" in txResult) {
         return {
-            upSubstates: result.AcceptFeeRejectRest[0].up_substates,
-            downSubstates: result.AcceptFeeRejectRest[0].down_substates,
+            upSubstates: txResult.Accept.up_substates,
+            downSubstates: txResult.Accept.down_substates,
         };
     }
-    if (result && txResultCheck.isAccept(result)) {
-        return { upSubstates: result.Accept.up_substates, downSubstates: result.Accept.down_substates };
+    if ("Reject" in txResult) {
+        throw new Error(`Transaction rejected: ${txResult.Reject}`);
     }
-    return { upSubstates: [], downSubstates: [] };
+    if ("AcceptFeeRejectRest" in txResult) {
+        return {
+            upSubstates: txResult.AcceptFeeRejectRest[0].up_substates,
+            downSubstates: txResult.AcceptFeeRejectRest[0].down_substates,
+        };
+    }
+    throw new Error(`Unexpected transaction result: ${JSON.stringify(txResult)}`);
 }

package/dist/helpers/workspace.d.ts

@@ -1,19 +1,29 @@
-import { WorkspaceArg } from "@tari-project/tarijs-types";
+import { TransactionArg } from "@tari-project/tarijs-types";
 /**
- *
- * @param key workspace name
- * @returns encoded hex value
- * @example
- * key: "bucket"   -> "6275636b6574"
- * key: "bucket.0" -> "6275636b65742e30"
- * key: "bucket.1" -> "6275636b65742e31"
+ * A parsed workspace key string into an object with name and optional offset.
+ * Examples:
+ * "bucket"   -> { name: "bucket", offset: undefined }
+ * "bucket.0" -> { name: "bucket", offset: 0 }
  */
-export declare function toWorkspace(key: string): string;
+export interface ParsedBuildersWorkspaceKey {
+    name: string;
+    offset: number | null;
+}
 /**
  *
- * @param key workspace name
- * @returns formatted Workspace data
+ * @param key workspace name. Offsets can be specified with a dot notation, e.g. "bucket.0"
+ * @returns Parsed workspace key object
  * @example
- * key: "bucket" -> { Workspace: "6275636b6574" }
+ * key: "bucket"   -> { name: "bucket", offset: undefined }
+ * key: "bucket.0" -> { name: "bucket", offset: 0 }
+ * key: "bucket.1" -> { name: "bucket", offset: 1 }
+ */
+export declare function parseWorkspaceStringKey(key: string): ParsedBuildersWorkspaceKey;
+/**
+ * Either a literal Transaction Arg or a named workspace argument.
+ * Named workspace arguments are used to refer to a workspace by name,
+ * and are converted to numeric IDs by the TransactionBuilder.
  */
-export declare function fromWorkspace(key: string): WorkspaceArg;
+export type NamedArg = {
+    Workspace: string;
+} | TransactionArg;

package/dist/helpers/workspace.js

@@ -1,22 +1,21 @@
 /**
  *
- * @param key workspace name
- * @returns encoded hex value
+ * @param key workspace name. Offsets can be specified with a dot notation, e.g. "bucket.0"
+ * @returns Parsed workspace key object
  * @example
- * key: "bucket"   -> "6275636b6574"
- * key: "bucket.0" -> "6275636b65742e30"
- * key: "bucket.1" -> "6275636b65742e31"
+ * key: "bucket"   -> { name: "bucket", offset: undefined }
+ * key: "bucket.0" -> { name: "bucket", offset: 0 }
+ * key: "bucket.1" -> { name: "bucket", offset: 1 }
  */
-export function toWorkspace(key) {
-    return Buffer.from(key).toString("hex");
-}
-/**
- *
- * @param key workspace name
- * @returns formatted Workspace data
- * @example
- * key: "bucket" -> { Workspace: "6275636b6574" }
- */
-export function fromWorkspace(key) {
-    return { Workspace: Buffer.from(key).toString("hex") };
+export function parseWorkspaceStringKey(key) {
+    const parts = key.split(".");
+    if (parts.length > 2) {
+        throw new Error("Invalid workspace key format. Only one dot is allowed.");
+    }
+    const name = parts[0];
+    const offset = parts[1] ? parseInt(parts[1], 10) : null;
+    return {
+        name,
+        offset,
+    };
 }

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * from "@tari-project/tarijs-types";
 export { TransactionBuilder, TransactionRequest, TariMethodDefinition, TariFunctionDefinition } from "./transaction";
-export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, fromWorkspace, toWorkspace, } from "./helpers";
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, parseWorkspaceStringKey, } from "./helpers";

package/dist/index.js

@@ -1,3 +1,3 @@
 export * from "@tari-project/tarijs-types";
 export { TransactionBuilder, TransactionRequest } from "./transaction";
-export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, fromWorkspace, toWorkspace, } from "./helpers";
+export { buildTransactionRequest, submitAndWaitForTransaction, waitForTransactionResult, parseWorkspaceStringKey, } from "./helpers";

package/dist/transaction/TransactionBuilder.d.ts

@@ -1,16 +1,19 @@
-import { ComponentAddress, ConfidentialClaim, ConfidentialWithdrawProof, Instruction, ResourceAddress, SubstateRequirement, Transaction, TransactionSignature, UnsignedTransaction, PublishedTemplateAddress, SubstateType, TransactionArg } from "@tari-project/tarijs-types";
+import { TransactionArg } from "@tari-project/tarijs-types";
+import { Amount, ComponentAddress, ConfidentialClaim, ConfidentialWithdrawProof, Instruction, ResourceAddress, SubstateRequirement, Transaction, TransactionSignature, UnsignedTransaction, PublishedTemplateAddress, UnsignedTransactionV1, AllocatableAddressType } from "@tari-project/typescript-bindings";
+import { NamedArg } from "../helpers/workspace";
 export interface TransactionConstructor {
     new (unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]): Transaction;
 }
 export interface TariFunctionDefinition {
     functionName: string;
-    args?: TransactionArg[];
+    args?: NamedArg[];
     templateAddress: PublishedTemplateAddress;
 }
 export interface TariMethodDefinition {
     methodName: string;
     args?: TransactionArg[];
-    componentAddress: ComponentAddress;
+    componentAddress?: ComponentAddress;
+    fromWorkspace?: string;
 }
 export interface TariCreateAccountDefinition {
     methodName: string;
@@ -36,28 +39,31 @@ export interface Builder {
     withInstructions(instructions: Instruction[]): this;
     withFeeInstructions(instructions: Instruction[]): this;
     withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => this): this;
-    withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+    withUnsignedTransaction(unsignedTransaction: UnsignedTransactionV1): this;
     feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this;
     feeTransactionPayFromComponentConfidential(componentAddress: ComponentAddress, proof: ConfidentialWithdrawProof): this;
-    buildUnsignedTransaction(): UnsignedTransaction;
+    buildUnsignedTransaction(): UnsignedTransactionV1;
     build(): Transaction;
 }
 export declare class TransactionBuilder implements Builder {
     private unsignedTransaction;
     private signatures;
-    constructor();
+    private allocatedIds;
+    private current_id;
+    constructor(network: number);
     callFunction<T extends TariFunctionDefinition>(func: T, args: Exclude<T["args"], undefined>): this;
     callMethod<T extends TariMethodDefinition>(method: T, args: Exclude<T["args"], undefined>): this;
     createAccount(ownerPublicKey: string, workspaceBucket?: string): this;
     createProof(account: ComponentAddress, resourceAddress: ResourceAddress): this;
     claimBurn(claim: ConfidentialClaim): this;
-    allocateAddress(substateType: SubstateType, workspaceId: string): this;
+    allocateAddress(allocatableType: AllocatableAddressType, workspaceId: string): this;
+    assertBucketContains(workspaceName: string, resource_address: ResourceAddress, min_amount: Amount): this;
     /**
      * The `SaveVar` method replaces
      * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
      * to make saving variables easier.
      */
-    saveVar(key: string): this;
+    saveVar(name: string): this;
     /**
      * Adds a fee instruction that calls the `take_fee` method on a component.
      * This method must exist and return a Bucket with containing revealed confidential XTR resource.
@@ -72,7 +78,7 @@ export declare class TransactionBuilder implements Builder {
      */
     feeTransactionPayFromComponentConfidential(componentAddress: ComponentAddress, proof: ConfidentialWithdrawProof): this;
     dropAllProofsInWorkspace(): this;
-    withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+    withUnsignedTransaction(unsignedTransaction: UnsignedTransactionV1): this;
     withFeeInstructions(instructions: Instruction[]): this;
     withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => TransactionBuilder): this;
     addInstruction(instruction: Instruction): this;
@@ -82,6 +88,10 @@ export declare class TransactionBuilder implements Builder {
     withInputs(inputs: SubstateRequirement[]): this;
     withMinEpoch(minEpoch: number): this;
     withMaxEpoch(maxEpoch: number): this;
-    buildUnsignedTransaction(): UnsignedTransaction;
+    buildUnsignedTransaction(): UnsignedTransactionV1;
     build(): Transaction;
+    private addNamedId;
+    private getNamedId;
+    private getOffsetIdFromWorkspaceName;
+    private resolveArgs;
 }

package/dist/transaction/TransactionBuilder.js

@@ -1,51 +1,68 @@
 //   Copyright 2024 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
-import { toWorkspace } from "../helpers";
 import { TransactionRequest } from "./TransactionRequest";
+import { parseWorkspaceStringKey } from "../helpers";
 export class TransactionBuilder {
     unsignedTransaction;
     signatures;
-    constructor() {
+    allocatedIds;
+    current_id;
+    constructor(network) {
         this.unsignedTransaction = {
-            feeInstructions: [],
+            network,
+            fee_instructions: [],
             instructions: [],
             inputs: [],
-            filledInputs: [],
-            minEpoch: undefined,
-            maxEpoch: undefined,
+            min_epoch: null,
+            max_epoch: null,
+            dry_run: false,
+            is_seal_signer_authorized: false
         };
         this.signatures = [];
+        this.allocatedIds = new Map();
+        this.current_id = 0;
     }
     callFunction(func, args) {
+        const resolvedArgs = this.resolveArgs(args);
         return this.addInstruction({
             CallFunction: {
-                template_address: func.templateAddress,
+                address: func.templateAddress,
                 function: func.functionName,
-                args,
+                args: resolvedArgs,
             },
         });
     }
     callMethod(method, args) {
+        const call = method.componentAddress ?
+            { Address: method.componentAddress } :
+            // NOTE: offset IDs are not supported for method calls
+            { Workspace: this.getNamedId(method.fromWorkspace) };
+        const resolvedArgs = this.resolveArgs(args);
         return this.addInstruction({
             CallMethod: {
-                component_address: method.componentAddress,
+                call,
                 method: method.methodName,
-                args,
+                args: resolvedArgs,
             },
         });
     }
     createAccount(ownerPublicKey, workspaceBucket) {
+        const workspace_id = workspaceBucket ?
+            this.getOffsetIdFromWorkspaceName(workspaceBucket) :
+            null;
         return this.addInstruction({
             CreateAccount: {
-                owner_public_key: ownerPublicKey,
-                workspace_bucket: workspaceBucket ?? null,
+                public_key_address: ownerPublicKey,
+                owner_rule: null, // Custom owner rule is not set by default
+                access_rules: null, // Custom access rules are not set by default
+                workspace_id,
             },
         });
     }
     createProof(account, resourceAddress) {
         return this.addInstruction({
             CallMethod: {
-                component_address: account,
+                call: { Address: account },
                 method: "create_proof_for_resource",
                 args: [resourceAddress],
             },
@@ -58,11 +75,22 @@ export class TransactionBuilder {
             },
         });
     }
-    allocateAddress(substateType, workspaceId) {
+    allocateAddress(allocatableType, workspaceId) {
+        const workspace_id = this.addNamedId(workspaceId);
         return this.addInstruction({
             AllocateAddress: {
-                substate_type: substateType,
-                workspace_id: workspaceId,
+                allocatable_type: allocatableType,
+                workspace_id,
+            },
+        });
+    }
+    assertBucketContains(workspaceName, resource_address, min_amount) {
+        const key = this.getOffsetIdFromWorkspaceName(workspaceName);
+        return this.addInstruction({
+            AssertBucketContains: {
+                key,
+                resource_address,
+                min_amount,
             },
         });
     }
@@ -71,10 +99,11 @@ export class TransactionBuilder {
      * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
      * to make saving variables easier.
      */
-    saveVar(key) {
+    saveVar(name) {
+        let key = this.addNamedId(name);
         return this.addInstruction({
             PutLastInstructionOutputOnWorkspace: {
-                key: toWorkspace(key),
+                key,
             },
         });
     }
@@ -87,7 +116,7 @@ export class TransactionBuilder {
     feeTransactionPayFromComponent(componentAddress, maxFee) {
         return this.addFeeInstruction({
             CallMethod: {
-                component_address: componentAddress,
+                call: { Address: componentAddress },
                 method: "pay_fee",
                 args: [maxFee],
             },
@@ -101,7 +130,7 @@ export class TransactionBuilder {
     feeTransactionPayFromComponentConfidential(componentAddress, proof) {
         return this.addFeeInstruction({
             CallMethod: {
-                component_address: componentAddress,
+                call: { Address: componentAddress },
                 method: "pay_fee_confidential",
                 args: [proof],
             },
@@ -116,13 +145,13 @@ export class TransactionBuilder {
         return this;
     }
     withFeeInstructions(instructions) {
-        this.unsignedTransaction.feeInstructions = instructions;
+        this.unsignedTransaction.fee_instructions = instructions;
         this.signatures = [];
         return this;
     }
     withFeeInstructionsBuilder(builder) {
-        const newBuilder = builder(new TransactionBuilder());
-        this.unsignedTransaction.feeInstructions = newBuilder.unsignedTransaction.instructions;
+        const newBuilder = builder(new TransactionBuilder(this.unsignedTransaction.network));
+        this.unsignedTransaction.fee_instructions = newBuilder.unsignedTransaction.instructions;
         this.signatures = [];
         return this;
     }
@@ -132,7 +161,7 @@ export class TransactionBuilder {
         return this;
     }
     addFeeInstruction(instruction) {
-        this.unsignedTransaction.feeInstructions.push(instruction);
+        this.unsignedTransaction.fee_instructions.push(instruction);
         this.signatures = [];
         return this;
     }
@@ -152,13 +181,13 @@ export class TransactionBuilder {
         return this;
     }
     withMinEpoch(minEpoch) {
-        this.unsignedTransaction.minEpoch = minEpoch;
+        this.unsignedTransaction.min_epoch = minEpoch;
         // Reset the signatures as they are no longer valid
         this.signatures = [];
         return this;
     }
     withMaxEpoch(maxEpoch) {
-        this.unsignedTransaction.maxEpoch = maxEpoch;
+        this.unsignedTransaction.max_epoch = maxEpoch;
         // Reset the signatures as they are no longer valid
         this.signatures = [];
         return this;
@@ -167,6 +196,32 @@ export class TransactionBuilder {
         return this.unsignedTransaction;
     }
     build() {
-        return new TransactionRequest(this.unsignedTransaction, this.signatures);
+        return new TransactionRequest(this.buildUnsignedTransaction(), this.signatures);
+    }
+    addNamedId(name) {
+        const id = this.current_id;
+        this.allocatedIds.set(name, id);
+        this.current_id += 1;
+        return id;
+    }
+    getNamedId(name) {
+        return this.allocatedIds.get(name);
+    }
+    getOffsetIdFromWorkspaceName(name) {
+        const parsed = parseWorkspaceStringKey(name);
+        const id = this.getNamedId(parsed.name);
+        if (id === undefined) {
+            throw new Error(`No workspace with name ${parsed.name} found`);
+        }
+        return { id, offset: parsed.offset };
+    }
+    resolveArgs(args) {
+        return args.map((arg) => {
+            if (typeof arg === "object" && "Workspace" in arg) {
+                const workspaceId = this.getOffsetIdFromWorkspaceName(arg.Workspace);
+                return { Workspace: workspaceId };
+            }
+            return arg;
+        });
     }
 }

package/dist/transaction/TransactionRequest.d.ts

@@ -1,25 +1,16 @@
-import { Epoch, Instruction, SubstateRequirement, Transaction, TransactionSignature, UnsignedTransaction, VersionedSubstateId } from "@tari-project/tarijs-types";
+import { Epoch, Instruction, SubstateRequirement, Transaction, UnsignedTransactionV1, TransactionSignature, VersionedSubstateId, TransactionV1 } from "@tari-project/typescript-bindings";
 export declare class TransactionRequest implements Transaction {
     id: string;
-    feeInstructions: Array<Instruction>;
-    instructions: Array<Instruction>;
-    inputs: Array<SubstateRequirement>;
-    signatures: Array<TransactionSignature>;
-    unsignedTransaction: UnsignedTransaction;
-    minEpoch?: Epoch;
-    maxEpoch?: Epoch;
-    filledInputs: VersionedSubstateId[];
-    constructor(unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]);
+    V1: TransactionV1;
+    constructor(unsignedTransaction: UnsignedTransactionV1, signatures: TransactionSignature[]);
     withFilledInputs(filled_inputs: Array<VersionedSubstateId>): this;
-    getUnsignedTransaction(): UnsignedTransaction;
+    getUnsignedTransaction(): UnsignedTransactionV1;
     getFeeInstructions(): Instruction[];
     getInstructions(): Instruction[];
     getSignatures(): TransactionSignature[];
     getInputs(): SubstateRequirement[];
-    getFilledInputs(): VersionedSubstateId[];
-    getFilledInputsMut(): VersionedSubstateId[];
-    getMinEpoch(): Epoch | undefined;
-    getMaxEpoch(): Epoch | undefined;
+    getMinEpoch(): Epoch | null;
+    getMaxEpoch(): Epoch | null;
     setId(id: string): void;
     getId(): string;
 }

package/dist/transaction/TransactionRequest.js

@@ -1,55 +1,47 @@
 ///TODO this implementation is not fully done, see:
-/// https://github.com/tari-project/tari-dan/blob/development/dan_layer/transaction/src/transaction.rs
+/// https://github.com/tari-project/tari-ootle/blob/development/dan_layer/transaction/src/transaction.rs
 export class TransactionRequest {
     id;
-    feeInstructions;
-    instructions;
-    inputs;
-    signatures;
-    unsignedTransaction;
-    minEpoch;
-    maxEpoch;
-    filledInputs;
+    V1;
     constructor(unsignedTransaction, signatures) {
         this.id = "";
-        this.feeInstructions = unsignedTransaction.feeInstructions;
-        this.instructions = unsignedTransaction.instructions;
-        this.inputs = unsignedTransaction.inputs;
-        this.signatures = signatures;
-        this.minEpoch = unsignedTransaction.minEpoch;
-        this.maxEpoch = unsignedTransaction.maxEpoch;
-        // Inputs filled by some authority. These are not part of the transaction hash nor the signature
-        this.filledInputs = [];
+        this.V1 = {
+            body: {
+                transaction: unsignedTransaction,
+                signatures,
+            },
+            seal_signature: {
+                public_key: "",
+                signature: {
+                    public_nonce: "",
+                    signature: "",
+                },
+            },
+        };
     }
     withFilledInputs(filled_inputs) {
         return { ...this, filled_inputs };
     }
     getUnsignedTransaction() {
-        return this.unsignedTransaction;
+        return this.V1.body.transaction;
     }
     getFeeInstructions() {
-        return this.feeInstructions;
+        return this.V1.body.transaction.fee_instructions;
     }
     getInstructions() {
-        return this.instructions;
+        return this.V1.body.transaction.instructions;
     }
     getSignatures() {
-        return this.signatures;
+        return this.V1.body.signatures;
     }
     getInputs() {
-        return this.inputs;
-    }
-    getFilledInputs() {
-        return this.filledInputs;
-    }
-    getFilledInputsMut() {
-        return this.filledInputs;
+        return this.V1.body.transaction.inputs;
     }
     getMinEpoch() {
-        return this.minEpoch;
+        return this.V1.body.transaction.min_epoch;
     }
     getMaxEpoch() {
-        return this.maxEpoch;
+        return this.V1.body.transaction.max_epoch;
     }
     setId(id) {
         this.id = id;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs-builders",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -10,9 +10,10 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@tari-project/tari-signer": "^0.6.0",
-    "@tari-project/tari-universe-signer": "^0.6.0",
-    "@tari-project/tarijs-types": "^0.6.0"
+    "@tari-project/typescript-bindings": ">=1.9.1",
+    "@tari-project/tari-universe-signer": "^0.9.0",
+    "@tari-project/tarijs-types": "^0.9.0",
+    "@tari-project/tari-signer": "^0.9.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.1",