@tari-project/tarijs 0.4.0 → 0.4.2

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

@@ -0,0 +1,97 @@
+import { TariUniverseProvider } from "@tari-project/tari-universe-provider";
+import { TariProvider, SubmitTransactionRequest, SubstateRequirement } from "@tari-project/tari-provider";
+import {
+  Transaction,
+  TransactionResult,
+  TransactionStatus,
+  DownSubstates,
+  UpSubstates,
+  FinalizeResultStatus,
+  TxResultAccept,
+  SubmitTxResult
+} from "@tari-project/tarijs-types";
+
+export function buildTransactionRequest(
+  transaction: Transaction,
+  accountId: number,
+  requiredSubstates: SubstateRequirement[],
+  inputRefs = [],
+  isDryRun = false,
+  network = 0,
+  isSealSignerAuthorized = true,
+  detectInputsUseUnversioned = true,
+): SubmitTransactionRequest {
+  return {
+    //TODO refactor SubTxReq type to not use 'object[]' and types match
+    // https://github.com/tari-project/tari.js/issues/25
+    network,
+    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,
+  };
+}
+
+export async function submitAndWaitForTransaction(
+  provider: TariProvider,
+  req: SubmitTransactionRequest,
+): Promise<SubmitTxResult> {
+  try {
+    const response = await provider.submitTransaction(req);
+    const result = await waitForTransactionResult(provider, response.transaction_id);
+
+    return {
+      response,
+      result,
+    };
+  } catch (e) {
+    throw new Error(`Transaction failed: ${e}`);
+  }
+}
+
+export async function waitForTransactionResult(
+  provider: TariProvider | TariUniverseProvider,
+  transactionId: string,
+): Promise<TransactionResult> {
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const resp = await provider.getTransactionResult(transactionId);
+    const FINALIZED_STATUSES = [
+      TransactionStatus.Accepted,
+      TransactionStatus.Rejected,
+      TransactionStatus.InvalidTransaction,
+      TransactionStatus.OnlyFeeAccepted,
+      TransactionStatus.DryRun,
+    ];
+
+    if (resp.status == TransactionStatus.Rejected) {
+      throw new Error(`Transaction rejected: ${JSON.stringify(resp.result)}`);
+    }
+    if (FINALIZED_STATUSES.includes(resp.status)) {
+      return resp as any as TransactionResult; //TODO fix: type mismatch (https://github.com/tari-project/tari.js/issues/29)
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+}
+
+export function getAcceptResultSubstates(
+  txResult: TransactionResult,
+): { upSubstates: UpSubstates; downSubstates: DownSubstates } | undefined {
+  const result = txResult.result?.result;
+
+  if (result && isAccept(result)) {
+    return { upSubstates: result.Accept.up_substates, downSubstates: result.Accept.down_substates };
+  }
+  return undefined;
+}
+
+function isAccept(result: FinalizeResultStatus): result is TxResultAccept {
+  return "Accept" in result;
+}

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

@@ -0,0 +1,32 @@
+import { WorkspaceArg } from "@tari-project/tarijs-types";
+
+/**
+ *
+ * @param key workspace name
+ * @returns encoded Uint8Array value
+ * @example
+ * key: "0"   -> [ 48 ]
+ * key: "0.0" -> [ 48, 46, 48 ]
+ * key: "0.1" -> [ 48, 46, 49 ]
+ *
+ * key: "bucket"   -> [ 98, 117, 99, 107, 101, 116 ]
+ * key: "bucket.0" -> [ 98, 117, 99, 107, 101, 116, 46, 48 ]
+ * key: "bucket.1" -> [ 98, 117, 99, 107, 101, 116, 46, 49 ]
+ */
+export function toWorkspace(key: string): number[] {
+  const encoder = new TextEncoder();
+  return Array.from(encoder.encode(key));
+}
+
+/**
+ *
+ * @param key workspace name
+ * @returns formatted Workspace data
+ * @example
+ * key: "bucket" -> { Workspace: [ 98, 117, 99, 107, 101, 116 ] }
+ */
+export function fromWorkspace(key: string): WorkspaceArg {
+  const encoder = new TextEncoder();
+  const encodedKey = encoder.encode(key);
+  return { Workspace: Array.from(encodedKey) };
+}

package/packages/builders/src/index.ts

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

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

@@ -0,0 +1,276 @@
+//   Copyright 2024 The Tari Project
+//   SPDX-License-Identifier: BSD-3-Clause
+import { toWorkspace } from "../helpers";
+
+import { TransactionRequest } from "./TransactionRequest";
+import {
+  ComponentAddress,
+  ConfidentialClaim,
+  ConfidentialWithdrawProof,
+  Instruction,
+  ResourceAddress,
+  SubstateRequirement,
+  Transaction,
+  TransactionSignature,
+  UnsignedTransaction,
+  TemplateAddress,
+  Arg,
+} from "@tari-project/tarijs-types";
+
+
+export interface TransactionConstructor {
+  new(unsignedTransaction: UnsignedTransaction, signatures: TransactionSignature[]): Transaction;
+}
+
+export interface TariFunctionDefinition {
+  functionName: string;
+  args?: Arg[];
+  templateAddress: TemplateAddress;
+}
+
+export interface TariMethodDefinition {
+  methodName: string;
+  args?: Arg[];
+  componentAddress: ComponentAddress;
+}
+
+export interface TariCreateAccountDefinition {
+  methodName: string;
+  args?: {
+    ownerPublicKey: string;
+    workspaceBucket?: string;
+  };
+}
+
+export interface Builder {
+  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;
+
+  saveVar(key: string): this;
+
+  dropAllProofsInWorkspace(): this;
+
+  claimBurn(claim: ConfidentialClaim): this;
+
+  addInput(inputObject: SubstateRequirement): this;
+
+  addInstruction(instruction: Instruction): this;
+
+  addFeeInstruction(instruction: Instruction): this;
+
+  withMinEpoch(minEpoch: number): this;
+
+  withMaxEpoch(maxEpoch: number): this;
+
+  withInputs(inputs: SubstateRequirement[]): this;
+
+  withInstructions(instructions: Instruction[]): this;
+
+  withFeeInstructions(instructions: Instruction[]): this;
+
+  withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => this): this;
+
+  withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this;
+
+  feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this;
+
+  feeTransactionPayFromComponentConfidential(
+    componentAddress: ComponentAddress,
+    proof: ConfidentialWithdrawProof,
+  ): this;
+
+  buildUnsignedTransaction(): UnsignedTransaction;
+
+  build(): Transaction;
+}
+
+export class TransactionBuilder implements Builder {
+  private unsignedTransaction: UnsignedTransaction;
+  private signatures: TransactionSignature[];
+
+  constructor() {
+    this.unsignedTransaction = {
+      feeInstructions: [],
+      instructions: [],
+      inputs: [],
+      filledInputs: [],
+      minEpoch: undefined,
+      maxEpoch: undefined,
+    };
+    this.signatures = [];
+  }
+
+  public callFunction<T extends TariFunctionDefinition>(func: T, args: Exclude<T["args"], undefined>): this {
+    return this.addInstruction({
+      CallFunction: {
+        template_address: func.templateAddress,
+        function: func.functionName,
+        args,
+      },
+    });
+  }
+
+  public callMethod<T extends TariMethodDefinition>(method: T, args: Exclude<T["args"], undefined>): this {
+    return this.addInstruction({
+      CallMethod: {
+        component_address: method.componentAddress,
+        method: method.methodName,
+        args,
+      },
+    });
+  }
+
+  public createAccount(ownerPublicKey: string, workspaceBucket?: string): this {
+    return this.addInstruction({
+      CreateAccount: {
+        owner_public_key: ownerPublicKey,
+        workspace_bucket: workspaceBucket ?? null,
+      },
+    });
+  }
+
+  public createProof(account: ComponentAddress, resourceAddress: ResourceAddress): this {
+    return this.addInstruction({
+      CallMethod: {
+        component_address: account,
+        method: "create_proof_for_resource",
+        args: [resourceAddress],
+      },
+    });
+  }
+
+  public claimBurn(claim: ConfidentialClaim): this {
+    return this.addInstruction({
+      ClaimBurn: {
+        claim,
+      },
+    });
+  }
+
+  /**
+   * The `SaveVar` method replaces
+   * `PutLastInstructionOutputOnWorkspace: { key: Array<number> }`
+   * to make saving variables easier.
+   */
+  public saveVar(key: string): this {
+    return this.addInstruction({
+      PutLastInstructionOutputOnWorkspace: {
+        key: toWorkspace(key),
+      },
+    });
+  }
+
+  /**
+   * 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.
+   * This allows the fee to originate from sources other than the transaction sender's account.
+   * The fee instruction will lock up the `max_fee` amount for the duration of the transaction.
+   */
+  public feeTransactionPayFromComponent(componentAddress: ComponentAddress, maxFee: string): this {
+    return this.addFeeInstruction({
+      CallMethod: {
+        component_address: componentAddress,
+        method: "pay_fee",
+        args: [maxFee],
+      },
+    });
+  }
+
+  /**
+   * Adds a fee instruction that calls the `take_fee_confidential` method on a component.
+   * This method must exist and return a Bucket with containing revealed confidential XTR resource.
+   * This allows the fee to originate from sources other than the transaction sender's account.
+   */
+  public feeTransactionPayFromComponentConfidential(
+    componentAddress: ComponentAddress,
+    proof: ConfidentialWithdrawProof,
+  ): this {
+    return this.addFeeInstruction({
+      CallMethod: {
+        component_address: componentAddress,
+        method: "pay_fee_confidential",
+        args: [proof],
+      },
+    });
+  }
+
+  public dropAllProofsInWorkspace(): this {
+    return this.addInstruction("DropAllProofsInWorkspace");
+  }
+
+  public withUnsignedTransaction(unsignedTransaction: UnsignedTransaction): this {
+    this.unsignedTransaction = unsignedTransaction;
+    this.signatures = [];
+    return this;
+  }
+
+  public withFeeInstructions(instructions: Instruction[]): this {
+    this.unsignedTransaction.feeInstructions = instructions;
+    this.signatures = [];
+    return this;
+  }
+
+  public withFeeInstructionsBuilder(builder: (builder: TransactionBuilder) => TransactionBuilder): this {
+    const newBuilder = builder(new TransactionBuilder());
+    this.unsignedTransaction.feeInstructions = newBuilder.unsignedTransaction.instructions;
+    this.signatures = [];
+    return this;
+  }
+
+  public addInstruction(instruction: Instruction): this {
+    this.unsignedTransaction.instructions.push(instruction);
+    this.signatures = [];
+    return this;
+  }
+
+  public addFeeInstruction(instruction: Instruction): this {
+    this.unsignedTransaction.feeInstructions.push(instruction);
+    this.signatures = [];
+    return this;
+  }
+
+  public withInstructions(instructions: Instruction[]): this {
+    this.unsignedTransaction.instructions.push(...instructions);
+    this.signatures = [];
+    return this;
+  }
+
+  public addInput(inputObject: SubstateRequirement): this {
+    this.unsignedTransaction.inputs.push(inputObject);
+    this.signatures = [];
+    return this;
+  }
+
+  public withInputs(inputs: SubstateRequirement[]): this {
+    this.unsignedTransaction.inputs.push(...inputs);
+    this.signatures = [];
+    return this;
+  }
+
+  public withMinEpoch(minEpoch: number): this {
+    this.unsignedTransaction.minEpoch = minEpoch;
+    // Reset the signatures as they are no longer valid
+    this.signatures = [];
+    return this;
+  }
+
+  public withMaxEpoch(maxEpoch: number): this {
+    this.unsignedTransaction.maxEpoch = maxEpoch;
+    // Reset the signatures as they are no longer valid
+    this.signatures = [];
+    return this;
+  }
+
+  public buildUnsignedTransaction(): UnsignedTransaction {
+    return this.unsignedTransaction;
+  }
+
+  public build(): Transaction {
+    return new TransactionRequest(this.unsignedTransaction, this.signatures);
+  }
+}

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

@@ -0,0 +1,93 @@
+import {
+  Epoch,
+  Instruction,
+  SubstateRequirement,
+  Transaction,
+  TransactionId,
+  TransactionSignature,
+  UnsignedTransaction,
+  VersionedSubstateId,
+} from "@tari-project/tarijs-types";
+
+///TODO this implementation is not fully done, see:
+/// https://github.com/tari-project/tari-dan/blob/development/dan_layer/transaction/src/transaction.rs
+export class TransactionRequest implements Transaction {
+  id: TransactionId;
+  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[]) {
+    this.id = this.calculateHash();
+    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 = [];
+  }
+
+  private calculateHash(): TransactionId {
+    return "";
+  }
+
+  withFilledInputs(filled_inputs: Array<VersionedSubstateId>): this {
+    return { ...this, filled_inputs };
+  }
+
+  getId(): TransactionId {
+    return this.id;
+  }
+
+  checkId(): boolean {
+    const id = this.calculateHash();
+    return id === this.id;
+  }
+
+  getUnsignedTransaction(): UnsignedTransaction {
+    return this.unsignedTransaction;
+  }
+
+  getFeeInstructions(): Instruction[] {
+    return this.feeInstructions;
+  }
+
+  getInstructions(): Instruction[] {
+    return this.instructions;
+  }
+
+  getSignatures(): TransactionSignature[] {
+    return this.signatures;
+  }
+
+  getHash(): string {
+    return this.id;
+  }
+
+  getInputs(): SubstateRequirement[] {
+    return this.inputs;
+  }
+
+  getFilledInputs(): VersionedSubstateId[] {
+    return this.filledInputs;
+  }
+
+  getFilledInputsMut(): VersionedSubstateId[] {
+    return this.filledInputs;
+  }
+
+  getMinEpoch(): Epoch | undefined {
+    return this.minEpoch;
+  }
+
+  getMaxEpoch(): Epoch | undefined {
+    return this.maxEpoch;
+  }
+}

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

@@ -0,0 +1,2 @@
+export { TransactionBuilder, TariMethodDefinition, TariFunctionDefinition } from "./TransactionBuilder";
+export { TransactionRequest } from "./TransactionRequest";

package/packages/builders/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "references": [
+    {
+      "path": "../tari_provider"
+    },
+    {
+      "path": "../tari_universe"
+    },
+    {
+      "path": "../tarijs_types"
+    }
+  ]
+}

package/packages/metamask_provider/moon.yml

@@ -0,0 +1,55 @@
+language: "typescript"
+platform: "node"
+type: "library"
+
+fileGroups:
+  configs:
+    - "tsconfig.json"
+    - "package.json"
+    - "eslint.config.ts"
+  sources:
+    - "src/**/*"
+  tests:
+    - "integration-tests/**/*"
+
+tasks:
+  build:
+    command: "pnpm run build"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+    outputs:
+      - "dist"
+  format:
+    command: "pnpm run format"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    options:
+      runInCI: false
+  lint:
+    command: "pnpm run lint:fix"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    options:
+      runInCI: false
+    deps:
+      - "build"
+
+  lintCheck:
+    command: "pnpm run lint"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"
+    deps:
+      - "build"
+  formatCheck:
+    command: "pnpm run format:check"
+    inputs:
+      - "@files(sources)"
+      - "@files(configs)"
+      - "@files(tests)"

package/packages/metamask_provider/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tari-project/metamask-provider",
+  "version": "0.4.0",
+  "description": "",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@metamask/providers": "catalog:",
+    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/tarijs-types": "workspace:^",
+    "@tari-project/typescript-bindings": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}