@tari-project/tarijs 0.6.0 → 0.9.0

package/docusaurus/tari-docs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tari-docs",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "private": true,
   "scripts": {
     "docusaurus": "docusaurus",
@@ -15,7 +15,7 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@docusaurus/core": "3.7.0",
+    "@docusaurus/core": "^3.7.0",
     "@docusaurus/preset-classic": "3.7.0",
     "@docusaurus/remark-plugin-npm2yarn": "^3.7.0",
     "@mdx-js/react": "^3.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "keywords": [],

package/packages/builders/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs-builders",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -15,7 +15,8 @@
   "dependencies": {
     "@tari-project/tari-signer": "workspace:^",
     "@tari-project/tari-universe-signer": "workspace:^",
-    "@tari-project/tarijs-types": "workspace:^"
+    "@tari-project/tarijs-types": "workspace:^",
+    "@tari-project/typescript-bindings": "catalog:"
   },
   "devDependencies": {
     "@types/node": "catalog:",

package/packages/builders/src/helpers/index.ts

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

package/packages/builders/src/helpers/submitTransaction.ts

@@ -1,40 +1,28 @@
 import { TariUniverseSigner } from "@tari-project/tari-universe-signer";
 import { TariSigner } from "@tari-project/tari-signer";
 import {
-  Transaction,
+  ComponentAddress,
+  substateIdToString,
   TransactionResult,
-  TransactionStatus,
+  UnsignedTransactionV1,
+} from "@tari-project/typescript-bindings";
+import {
   DownSubstates,
   UpSubstates,
-  SubmitTxResult,
-  ReqSubstate,
+  getSubstateValueFromUpSubstates,
   SubmitTransactionRequest,
-  ComponentAddress,
+  TransactionStatus,
 } from "@tari-project/tarijs-types";
-import { getSubstateValueFromUpSubstates, substateIdToString, txResultCheck } from "@tari-project/tarijs-types";
+import { SubmitTxResult } from "@tari-project/tarijs-types/dist/TransactionResult";
 
 export function buildTransactionRequest(
-  transaction: Transaction,
+  transaction: UnsignedTransactionV1,
   accountId: number,
-  requiredSubstates: ReqSubstate[],
-  inputRefs = [],
-  isDryRun = false,
-  network = 0,
-  isSealSignerAuthorized = true,
   detectInputsUseUnversioned = true,
 ): SubmitTransactionRequest {
   return {
-    network,
+    transaction,
     account_id: accountId,
-    instructions: transaction.instructions as object[],
-    fee_instructions: transaction.feeInstructions as object[],
-    inputs: transaction.inputs,
-    input_refs: inputRefs as object[],
-    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,
   };
 }
@@ -95,7 +83,7 @@ export async function waitForTransactionResult(
       throw new Error(`Transaction rejected: ${JSON.stringify(resp.result)}`);
     }
     if (FINALIZED_STATUSES.includes(resp.status)) {
-      return resp as TransactionResult;
+      return resp.result?.result!;
     }
     await new Promise((resolve) => setTimeout(resolve, 1000));
   }
@@ -105,16 +93,23 @@ export function getAcceptResultSubstates(txResult: TransactionResult): {
   upSubstates: UpSubstates;
   downSubstates: DownSubstates;
 } {
-  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}`);
+  }
+
+  if ("AcceptFeeRejectRest" in txResult) {
+    return {
+      upSubstates: txResult.AcceptFeeRejectRest[0].up_substates,
+      downSubstates: txResult.AcceptFeeRejectRest[0].down_substates,
+    };
   }
-  return { upSubstates: [], downSubstates: [] };
+
+  throw new Error(`Unexpected transaction result: ${JSON.stringify(txResult)}`);
 }

package/packages/builders/src/helpers/workspace.ts

@@ -1,25 +1,42 @@
-import { WorkspaceArg } from "@tari-project/tarijs-types";
+import { TransactionArg, WorkspaceArg } 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 function toWorkspace(key: string): string {
-  return Buffer.from(key).toString("hex");
+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 function fromWorkspace(key: string): WorkspaceArg {
-  return { Workspace: Buffer.from(key).toString("hex") };
+export function parseWorkspaceStringKey(key: string): ParsedBuildersWorkspaceKey {
+  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,
+  };
 }
+
+/**
+ * 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 type NamedArg = { Workspace: string } | TransactionArg;

package/packages/builders/src/index.ts

@@ -4,6 +4,5 @@ export {
   buildTransactionRequest,
   submitAndWaitForTransaction,
   waitForTransactionResult,
-  fromWorkspace,
-  toWorkspace,
+  parseWorkspaceStringKey,
 } from "./helpers";

package/packages/builders/src/transaction/TransactionBuilder.ts

@@ -1,9 +1,10 @@
 //   Copyright 2024 The Tari Project
 //   SPDX-License-Identifier: BSD-3-Clause
-import { toWorkspace } from "../helpers";
 
 import { TransactionRequest } from "./TransactionRequest";
+import { TransactionArg } from "@tari-project/tarijs-types";
 import {
+  Amount,
   ComponentAddress,
   ConfidentialClaim,
   ConfidentialWithdrawProof,
@@ -14,24 +15,28 @@ import {
   TransactionSignature,
   UnsignedTransaction,
   PublishedTemplateAddress,
-  SubstateType,
-  TransactionArg,
-} from "@tari-project/tarijs-types";
+  WorkspaceOffsetId,
+  UnsignedTransactionV1, AllocatableAddressType,
+} from "@tari-project/typescript-bindings";
+import { parseWorkspaceStringKey } from "../helpers";
+import { NamedArg } from "../helpers/workspace";
 
 export interface TransactionConstructor {
-  new (unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]): Transaction;
+  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;
+  // These are mutually exclusive i.e. either componentAddress or fromWorkspace (TODO: define this properly in typescript)
+  componentAddress?: ComponentAddress;
+  fromWorkspace?: string,
 }
 
 export interface TariCreateAccountDefinition {
@@ -75,7 +80,7 @@ export interface Builder {
 
   withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => this): this;
 
-  withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+  withUnsignedTransaction(unsignedTransaction: UnsignedTransactionV1): this;
 
   feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this;
 
@@ -84,52 +89,70 @@ export interface Builder {
     proof: ConfidentialWithdrawProof,
   ): this;
 
-  buildUnsignedTransaction(): UnsignedTransaction;
+  buildUnsignedTransaction(): UnsignedTransactionV1;
 
   build(): Transaction;
 }
 
 export class TransactionBuilder implements Builder {
-  private unsignedTransaction: UnsignedTransaction;
+  private unsignedTransaction: UnsignedTransactionV1;
   private signatures: TransactionSignature[];
+  private allocatedIds: Map<string, number>;
+  private current_id: number;
 
-  constructor() {
+  constructor(network: number) {
     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;
   }
 
   public callFunction<T extends TariFunctionDefinition>(func: T, args: Exclude<T["args"], undefined>): this {
+    const resolvedArgs = this.resolveArgs(args);
     return this.addInstruction({
       CallFunction: {
-        template_address: func.templateAddress,
+        address: func.templateAddress,
         function: func.functionName,
-        args,
+        args: resolvedArgs,
       },
     });
   }
 
   public callMethod<T extends TariMethodDefinition>(method: T, args: Exclude<T["args"], undefined>): this {
+    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,
       },
     });
   }
 
   public createAccount(ownerPublicKey: string, workspaceBucket?: string): this {
+    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,
       },
     });
   }
@@ -137,7 +160,7 @@ export class TransactionBuilder implements Builder {
   public createProof(account: ComponentAddress, resourceAddress: ResourceAddress): this {
     return this.addInstruction({
       CallMethod: {
-        component_address: account,
+        call: {Address: account},
         method: "create_proof_for_resource",
         args: [resourceAddress],
       },
@@ -152,11 +175,23 @@ export class TransactionBuilder implements Builder {
     });
   }
 
-  public allocateAddress(substateType: SubstateType, workspaceId: string): this {
+  public allocateAddress(allocatableType: AllocatableAddressType, workspaceId: string): this {
+    const workspace_id = this.addNamedId(workspaceId);
     return this.addInstruction({
       AllocateAddress: {
-        substate_type: substateType,
-        workspace_id: workspaceId,
+        allocatable_type: allocatableType,
+        workspace_id,
+      },
+    });
+  }
+
+  public assertBucketContains(workspaceName: string, resource_address: ResourceAddress, min_amount: Amount): this {
+    const key = this.getOffsetIdFromWorkspaceName(workspaceName);
+    return this.addInstruction({
+      AssertBucketContains: {
+        key,
+        resource_address,
+        min_amount,
       },
     });
   }
@@ -166,10 +201,11 @@ export class TransactionBuilder implements Builder {
    * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
    * to make saving variables easier.
    */
-  public saveVar(key: string): this {
+  public saveVar(name: string): this {
+    let key = this.addNamedId(name);
     return this.addInstruction({
       PutLastInstructionOutputOnWorkspace: {
-        key: toWorkspace(key),
+        key,
       },
     });
   }
@@ -183,7 +219,7 @@ export class TransactionBuilder implements Builder {
   public feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this {
     return this.addFeeInstruction({
       CallMethod: {
-        component_address: componentAddress,
+        call: {Address: componentAddress},
         method: "pay_fee",
         args: [maxFee],
       },
@@ -201,7 +237,7 @@ export class TransactionBuilder implements Builder {
   ): this {
     return this.addFeeInstruction({
       CallMethod: {
-        component_address: componentAddress,
+        call: { Address:  componentAddress },
         method: "pay_fee_confidential",
         args: [proof],
       },
@@ -212,21 +248,21 @@ export class TransactionBuilder implements Builder {
     return this.addInstruction("DropAllProofsInWorkspace");
   }
 
-  public withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this {
+  public withUnsignedTransaction(unsignedTransaction: UnsignedTransactionV1): this {
     this.unsignedTransaction = unsignedTransaction;
     this.signatures = [];
     return this;
   }
 
   public withFeeInstructions(instructions: Instruction[]): this {
-    this.unsignedTransaction.feeInstructions = instructions;
+    this.unsignedTransaction.fee_instructions = instructions;
     this.signatures = [];
     return this;
   }
 
   public withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => TransactionBuilder): this {
-    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;
   }
@@ -238,7 +274,7 @@ export class TransactionBuilder implements Builder {
   }
 
   public addFeeInstruction(instruction: Instruction): this {
-    this.unsignedTransaction.feeInstructions.push(instruction);
+    this.unsignedTransaction.fee_instructions.push(instruction);
     this.signatures = [];
     return this;
   }
@@ -262,24 +298,55 @@ export class TransactionBuilder implements Builder {
   }
 
   public withMinEpoch(minEpoch: number): this {
-    this.unsignedTransaction.minEpoch = minEpoch;
+    this.unsignedTransaction.min_epoch = minEpoch;
     // Reset the signatures as they are no longer valid
     this.signatures = [];
     return this;
   }
 
   public withMaxEpoch(maxEpoch: number): this {
-    this.unsignedTransaction.maxEpoch = maxEpoch;
+    this.unsignedTransaction.max_epoch = maxEpoch;
     // Reset the signatures as they are no longer valid
     this.signatures = [];
     return this;
   }
 
-  public buildUnsignedTransaction(): UnsignedTransaction {
+  public buildUnsignedTransaction(): UnsignedTransactionV1 {
     return this.unsignedTransaction;
   }
 
   public build(): Transaction {
-    return new TransactionRequest(this.unsignedTransaction, this.signatures);
+    return new TransactionRequest(this.buildUnsignedTransaction(), this.signatures);
+  }
+
+  private addNamedId(name: string): number {
+    const id = this.current_id;
+    this.allocatedIds.set(name, id);
+    this.current_id += 1;
+    return id;
   }
+
+  private getNamedId(name: string): number | undefined {
+    return this.allocatedIds.get(name);
+  }
+
+  private getOffsetIdFromWorkspaceName(name: string): WorkspaceOffsetId {
+    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 };
+  }
+
+  private resolveArgs(args: NamedArg[]): TransactionArg[] {
+    return args.map((arg) => {
+      if (typeof arg === "object" && "Workspace" in arg) {
+        const workspaceId = this.getOffsetIdFromWorkspaceName(arg.Workspace);
+        return { Workspace: workspaceId };
+      }
+      return arg;
+    });
+  }
+
 }

package/packages/builders/src/transaction/TransactionRequest.ts

@@ -3,74 +3,66 @@ import {
   Instruction,
   SubstateRequirement,
   Transaction,
+  UnsignedTransactionV1,
   TransactionSignature,
-  UnsignedTransaction,
   VersionedSubstateId,
-} from "@tari-project/tarijs-types";
+  TransactionV1,
+} from "@tari-project/typescript-bindings";
+
 
 ///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 implements Transaction {
   id: string;
-  feeInstructions: Array<Instruction>;
-  instructions: Array<Instruction>;
-  inputs: Array<SubstateRequirement>;
-  signatures: Array<TransactionSignature>;
-  unsignedTransaction: UnsignedTransaction;
-  minEpoch?: Epoch;
-  maxEpoch?: Epoch;
-  filledInputs: VersionedSubstateId[];
+  V1: TransactionV1;
 
-  constructor(unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]) {
+  constructor(unsignedTransaction: UnsignedTransactionV1, signatures: TransactionSignature[]) {
     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: Array<VersionedSubstateId>): this {
     return { ...this, filled_inputs };
   }
 
-  getUnsignedTransaction(): UnsignedTransaction {
-    return this.unsignedTransaction;
+  getUnsignedTransaction(): UnsignedTransactionV1 {
+    return this.V1.body.transaction;
   }
 
   getFeeInstructions(): Instruction[] {
-    return this.feeInstructions;
+    return this.V1.body.transaction.fee_instructions;
   }
 
   getInstructions(): Instruction[] {
-    return this.instructions;
+    return this.V1.body.transaction.instructions;
   }
 
   getSignatures(): TransactionSignature[] {
-    return this.signatures;
+    return this.V1.body.signatures;
   }
 
   getInputs(): SubstateRequirement[] {
-    return this.inputs;
-  }
-
-  getFilledInputs(): VersionedSubstateId[] {
-    return this.filledInputs;
-  }
-
-  getFilledInputsMut(): VersionedSubstateId[] {
-    return this.filledInputs;
+    return this.V1.body.transaction.inputs;
   }
 
-  getMinEpoch(): Epoch | undefined {
-    return this.minEpoch;
+  getMinEpoch(): Epoch | null {
+    return this.V1.body.transaction.min_epoch;
   }
 
-  getMaxEpoch(): Epoch | undefined {
-    return this.maxEpoch;
+  getMaxEpoch(): Epoch | null {
+    return this.V1.body.transaction.max_epoch;
   }
 
   setId(id: string): void {

package/packages/indexer_provider/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/indexer-provider",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "publishConfig": {

package/packages/metamask_signer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/metamask-signer",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "publishConfig": {