@tari-project/tarijs 0.4.0 → 0.4.2

package/packages/tarijs/src/cbor.spec.ts

@@ -0,0 +1,259 @@
+import { assert, describe, expect, it, vi } from "vitest";
+import { BinaryTag, CborValue, convertTaggedValue, getCborValueByPath, parseCbor } from "./cbor";
+
+describe("convertTaggedValue", () => {
+  it.each([
+    {
+      tag: BinaryTag.VaultId,
+      value: { Bytes: [1, 2, 3, 4, 255] },
+      expected: "vault_01020304ff",
+    },
+    {
+      tag: BinaryTag.ComponentAddress,
+      value: { Bytes: [1, 2, 3, 4, 255] },
+      expected: "component_01020304ff",
+    },
+    {
+      tag: BinaryTag.ResourceAddress,
+      value: { Bytes: [1, 2, 3, 4, 255] },
+      expected: "resource_01020304ff",
+    },
+  ])("converts tags with bytes into a string representation", ({ tag, value, expected }) => {
+    expect(convertTaggedValue(tag, value)).toEqual(expected);
+  });
+
+  it.each([
+    {
+      tag: BinaryTag.Metadata,
+      value: { Array: [{ Text: "One" }, { Text: "Two" }] },
+      expected: ["metadata", ["One", "Two"]],
+    },
+    {
+      tag: BinaryTag.Metadata,
+      value: {
+        Map: [
+          [{ Text: "key1" }, { Integer: 5 }],
+          [{ Text: "key2" }, { Integer: 3 }],
+        ],
+      },
+      expected: ["metadata", { key1: 5, key2: 3 }],
+    },
+  ])(
+    "converts other values into a tuple",
+    ({ tag, value, expected }: { tag: BinaryTag; value: unknown; expected: unknown }) => {
+      expect(convertTaggedValue(tag, value as CborValue)).toEqual(expected);
+    },
+  );
+
+  it("falls back to 'unknown' for unknown tags", () => {
+    expect(convertTaggedValue(55, { Bool: true })).toEqual(["unknown", true]);
+  });
+});
+
+describe("parseCbor", () => {
+  describe("Null", () => {
+    it("returns null", () => {
+      expect(parseCbor("Null")).toBeNull();
+    });
+  });
+
+  describe("Integer", () => {
+    it.each([
+      {
+        value: { Integer: 5 },
+        expected: 5,
+      },
+      {
+        value: { Integer: 3 },
+        expected: 3,
+      },
+    ])("returns an integer", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Float", () => {
+    it.each([
+      {
+        value: { Float: 3.9 },
+        expected: 3.9,
+      },
+      {
+        value: { Float: 3 },
+        expected: 3,
+      },
+    ])("returns a number", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Text", () => {
+    it.each([
+      {
+        value: { Text: "Some text" },
+        expected: "Some text",
+      },
+      {
+        value: { Text: "DEF" },
+        expected: "DEF",
+      },
+    ])("returns a string", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Bytes", () => {
+    it.each([
+      {
+        value: { Bytes: [1, 2, 0xff] },
+        expected: Uint8Array.from([1, 2, 0xff]),
+      },
+      {
+        value: { Bytes: [] },
+        expected: new Uint8Array(),
+      },
+    ])("returns Uint8Array", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Bool", () => {
+    it.each([
+      {
+        value: { Bool: true },
+        expected: true,
+      },
+      {
+        value: { Bool: false },
+        expected: false,
+      },
+    ])("returns a boolean", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Tag", () => {
+    it.each([
+      {
+        value: {
+          Tag: [BinaryTag.VaultId, { Bytes: [1, 2, 3, 4, 255] }],
+        },
+        expected: "vault_01020304ff",
+      },
+      {
+        value: { Tag: [BinaryTag.Metadata, { Array: [{ Text: "One" }, { Text: "Two" }] }] },
+        expected: ["metadata", ["One", "Two"]],
+      },
+    ])("returns a tag representation", ({ value, expected }: { value: unknown; expected: unknown }) => {
+      expect(parseCbor(value as CborValue)).toEqual(expected);
+    });
+  });
+
+  describe("Array", () => {
+    it.each([
+      {
+        value: {
+          Array: [{ Integer: 5 }, { Float: 3.9 }, { Text: "Some text" }, { Bytes: [1, 2, 0xff] }, { Bool: true }],
+        },
+        expected: [5, 3.9, "Some text", Uint8Array.from([1, 2, 0xff]), true],
+      },
+    ])("returns an array", ({ value, expected }) => {
+      expect(parseCbor(value)).toEqual(expected);
+    });
+  });
+
+  describe("Map", () => {
+    it.each([
+      {
+        value: {
+          Map: [
+            [{ Text: "key1" }, { Integer: 5 }],
+            [{ Text: "key2" }, { Float: 3.9 }],
+            [{ Text: "key3" }, { Text: "Some text" }],
+            [{ Text: "key4" }, { Bytes: [1, 2, 0xff] }],
+            [{ Text: "key5" }, { Bool: true }],
+            [{ Text: "key6" }, { Array: [{ Integer: 1 }, { Integer: 2 }] }],
+            [
+              { Text: "key_nested" },
+              {
+                Map: [
+                  [{ Text: "nested1" }, { Text: "Nested text" }],
+                  [{ Text: "nested2" }, { Integer: 2 }],
+                ],
+              },
+            ],
+          ],
+        },
+        expected: {
+          key1: 5,
+          key2: 3.9,
+          key3: "Some text",
+          key4: Uint8Array.from([1, 2, 0xff]),
+          key5: true,
+          key6: [1, 2],
+          key_nested: {
+            nested1: "Nested text",
+            nested2: 2,
+          },
+        },
+      },
+    ])("returns an object", ({ value, expected }: { value: unknown; expected: unknown }) => {
+      expect(parseCbor(value as CborValue)).toEqual(expected);
+    });
+  });
+  
+  it.each([{}, { Unknown: 2 }])("throws, when data in unknown format is found", (value: unknown) => {
+    expect(() => parseCbor(value as CborValue)).toThrow();
+  });
+});
+
+describe("getCborValueByPath", () => {
+  it.each([
+    {
+      path: "$.key1",
+      expected: 5,
+    },
+    {
+      path: "$.key3",
+      expected: "Some text",
+    },
+    {
+      path: "$.key6.1",
+      expected: 2,
+    },
+    {
+      path: "$.key_nested.nested1",
+      expected: "Nested text",
+    },
+    {
+      path: "$.missing.path",
+      expected: null,
+    },
+    {
+      path: "$.key6.999",
+      expected: null,
+    },
+  ])("gets value by path", ({ path, expected }) => {
+    const cbor: CborValue = {
+      Map: [
+        [{ Text: "key1" }, { Integer: 5 }],
+        [{ Text: "key2" }, { Float: 3.9 }],
+        [{ Text: "key3" }, { Text: "Some text" }],
+        [{ Text: "key4" }, { Bytes: [1, 2, 0xff] }],
+        [{ Text: "key5" }, { Bool: true }],
+        [{ Text: "key6" }, { Array: [{ Integer: 1 }, { Integer: 2 }] }],
+        [
+          { Text: "key_nested" },
+          {
+            Map: [
+              [{ Text: "nested1" }, { Text: "Nested text" }],
+              [{ Text: "nested2" }, { Integer: 2 }],
+            ],
+          },
+        ],
+      ],
+    };
+
+    expect(getCborValueByPath(cbor, path)).toEqual(expected);
+  });
+});

package/packages/tarijs/src/cbor.ts

@@ -0,0 +1,114 @@
+export type CborValue =
+  | { Map: Array<[CborValue, CborValue]> }
+  | { Array: CborValue[] }
+  | { Tag: [BinaryTag, CborValue] }
+  | { Bool: boolean }
+  | { Bytes: number[] }
+  | { Text: string }
+  | { Float: number }
+  | { Integer: number }
+  | "Null";
+
+export function parseCbor(value: CborValue): unknown {
+  if (typeof value === "string") {
+    if (value === "Null") {
+      return null;
+    }
+    throw new Error("Unknown CBOR value type");
+  }
+  if ("Map" in value) {
+    return Object.fromEntries(value.Map.map(([k, v]) => [parseCbor(k), parseCbor(v)]));
+  } else if ("Array" in value) {
+    return value.Array.map(parseCbor);
+  } else if ("Tag" in value) {
+    const [type, data] = value.Tag;
+    return convertTaggedValue(type, data);
+  } else if ("Bool" in value) {
+    return value.Bool;
+  } else if ("Bytes" in value) {
+    return new Uint8Array(value.Bytes);
+  } else if ("Text" in value) {
+    return value.Text;
+  } else if ("Float" in value) {
+    return value.Float;
+  } else if ("Integer" in value) {
+    return value.Integer;
+  }
+  throw new Error("Unknown CBOR value type");
+}
+
+export function getCborValueByPath(cborRepr: CborValue | null, path: string): unknown {
+  if (!cborRepr) {
+    return null;
+  }
+  let value = cborRepr;
+  for (const part of path.split(".")) {
+    if (part == "$") {
+      continue;
+    }
+    if (typeof value !== "object") {
+      return null;
+    }
+    if ("Map" in value) {
+      const mapEntry = value.Map.find((v) => parseCbor(v[0]) === part)?.[1];
+      if (mapEntry) {
+        value = mapEntry;
+        continue;
+      } else {
+        return null;
+      }
+    }
+
+    if ("Array" in value) {
+      const arr = value.Array;
+      const index = parseInt(part);
+      if (!Number.isNaN(index) && Array.isArray(arr) && arr.length > index) {
+        value = arr[index];
+        continue;
+      }
+    }
+
+    return null;
+  }
+  return parseCbor(value);
+}
+
+function uint8ArrayToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export enum BinaryTag {
+  ComponentAddress = 128,
+  Metadata = 129,
+  NonFungibleAddress = 130,
+  ResourceAddress = 131,
+  VaultId = 132,
+  BucketId = 133,
+  TransactionReceipt = 134,
+  ProofId = 135,
+  UnclaimedConfidentialOutputAddress = 136,
+  TemplateAddress = 137,
+  ValidatorNodeFeePool = 138,
+}
+
+const BINARY_TAG_KEYS = new Map<BinaryTag, string>([
+  [BinaryTag.ComponentAddress, "component"],
+  [BinaryTag.Metadata, "metadata"],
+  [BinaryTag.NonFungibleAddress, "nft"],
+  [BinaryTag.ResourceAddress, "resource"],
+  [BinaryTag.VaultId, "vault"],
+  [BinaryTag.BucketId, "bucket"],
+  [BinaryTag.TransactionReceipt, "transaction-receipt"],
+  [BinaryTag.ProofId, "proof"],
+  [BinaryTag.UnclaimedConfidentialOutputAddress, "unclaimed-confidential-output-address"],
+  [BinaryTag.TemplateAddress, "template-address"],
+  [BinaryTag.ValidatorNodeFeePool, "validator-node-fee-pool"],
+]);
+
+export function convertTaggedValue(type: number, value: CborValue): string | unknown {
+  const tag = BINARY_TAG_KEYS.get(type) ?? "unknown";
+  const decoded = parseCbor(value);
+  return decoded instanceof Uint8Array ? `${tag}_${uint8ArrayToHex(decoded)}` : [tag, decoded];
+}

package/packages/tarijs/src/index.ts

@@ -0,0 +1,72 @@
+import { TariProvider } from "@tari-project/tari-provider";
+import * as utils from "./utils";
+import { Network } from "./network";
+import {
+  Account,
+  TransactionStatus,
+  TransactionResult,
+  SubmitTransactionResponse,
+  SubmitTransactionRequest,
+  VaultBalances,
+  VaultData,
+  TemplateDefinition,
+  SubstateRequirement,
+  Substate,
+} from "@tari-project/tari-provider";
+import { MetamaskTariProvider } from "@tari-project/metamask-provider";
+import { MetaMaskInpageProvider } from "@metamask/providers";
+import {
+  WalletDaemonTariProvider,
+  WalletDaemonParameters,
+  TariPermissions,
+} from "@tari-project/wallet-daemon-provider";
+import { TariUniverseProvider, TariUniverseProviderParameters } from "@tari-project/tari-universe-provider";
+import * as permissions from "@tari-project/tari-permissions";
+import { WalletConnectTariProvider } from "@tari-project/wallet-connect-provider";
+import {
+  TransactionBuilder,
+  TransactionRequest,
+  buildTransactionRequest,
+  submitAndWaitForTransaction,
+  waitForTransactionResult,
+  fromWorkspace,
+  toWorkspace,
+} from "@tari-project/tarijs-builders";
+import * as templates from "./templates";
+import { parseCbor, getCborValueByPath } from "./cbor";
+
+export * from "@tari-project/tarijs-types";
+export {
+  utils,
+  Network,
+  TariProvider,
+  Account,
+  TransactionStatus,
+  TransactionResult,
+  SubmitTransactionResponse,
+  SubmitTransactionRequest,
+  VaultBalances,
+  VaultData,
+  TemplateDefinition,
+  SubstateRequirement,
+  MetamaskTariProvider,
+  WalletDaemonTariProvider,
+  WalletDaemonParameters,
+  TariUniverseProvider,
+  TariUniverseProviderParameters,
+  TariPermissions,
+  MetaMaskInpageProvider,
+  Substate,
+  permissions,
+  WalletConnectTariProvider,
+  TransactionBuilder,
+  TransactionRequest,
+  buildTransactionRequest,
+  submitAndWaitForTransaction,
+  waitForTransactionResult,
+  fromWorkspace,
+  toWorkspace,
+  templates,
+  parseCbor,
+  getCborValueByPath,
+};

package/packages/tarijs/src/network.ts

@@ -0,0 +1,8 @@
+export enum Network {
+  MainNet = 0x00,
+  StageNet = 0x01,
+  NextNet = 0x02,
+  LocalNet = 0x10,
+  Igor = 0x24,
+  Esmeralda = 0x26,
+}

package/packages/tarijs/src/templates/Account.ts

@@ -0,0 +1,98 @@
+import { ConfidentialWithdrawProof, NonFungibleId, ResourceAddress } from "@tari-project/typescript-bindings";
+import { Amount } from "@tari-project/tarijs-types";
+import { TariMethodDefinition, WorkspaceArg  } from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+/**
+ * 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.
+ * @param componentAddress
+ * @param maxFee
+ * @returns
+ */
+interface PayFeeMethod extends TariMethodDefinition {
+  methodName: "pay_fee";
+  args?: [Amount];
+}
+// /**
+//  * 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.
+//  * @param componentAddress
+//  * @param proof
+//  * @returns
+//  */
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+  methodName: "pay_fee_confidential";
+  args?: [ConfidentialWithdrawProof];
+}
+
+interface WithdrawMethod extends TariMethodDefinition {
+  methodName: "withdraw";
+  args?: [string, Amount];
+}
+
+interface DepositMethod extends TariMethodDefinition {
+  methodName: "deposit";
+  args?: WorkspaceArg[];
+}
+
+interface CreateProofForResourceMethod extends TariMethodDefinition {
+  methodName: "create_proof_for_resource";
+  args?: [ResourceAddress];
+}
+
+interface CreateProofByAmountMethod extends TariMethodDefinition {
+  methodName: "create_proof_by_amount";
+  args?: [ResourceAddress, Amount];
+}
+
+interface CreateProofByNonFungibleIdsMethod extends TariMethodDefinition {
+  methodName: "create_proof_by_non_fungible_ids";
+  args?: [ResourceAddress, NonFungibleId[]];
+}
+
+interface BalanceMethod extends TariMethodDefinition {
+  methodName: "balance";
+  args?: [ResourceAddress];
+}
+
+interface GetBalancesMethod extends TariMethodDefinition {
+  methodName: "get_balances";
+  args?: [];
+}
+
+export class AccountTemplate extends TemplateFactory {
+  public deposit: DepositMethod;
+  public withdraw: WithdrawMethod;
+  public createProofByAmount: CreateProofByAmountMethod;
+  public createProofByNonFungibleIds: CreateProofByNonFungibleIdsMethod;
+  public createProofForResource: CreateProofForResourceMethod;
+  public balance: BalanceMethod;
+  public getBalances: GetBalancesMethod;
+  public payFee: PayFeeMethod;
+  public payFeeConfidential: PayFeeConfidentialMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+
+  protected _initFunctions(): void {}
+  protected _initMethods(): void {
+    this.deposit = this._defineMethod<DepositMethod>("deposit");
+    this.withdraw = this._defineMethod<WithdrawMethod>("withdraw");
+    this.createProofByAmount = this._defineMethod<CreateProofByAmountMethod>("create_proof_by_amount");
+    this.createProofByNonFungibleIds = this._defineMethod<CreateProofByNonFungibleIdsMethod>(
+      "create_proof_by_non_fungible_ids",
+    );
+    this.createProofForResource = this._defineMethod<CreateProofForResourceMethod>("create_proof_for_resource");
+    this.balance = this._defineMethod<BalanceMethod>("balance");
+    this.getBalances = this._defineMethod<GetBalancesMethod>("get_balances");
+    this.payFee = this._defineMethod<PayFeeMethod>("pay_fee");
+    this.payFeeConfidential = this._defineMethod<PayFeeConfidentialMethod>("pay_fee_confidential");
+  }
+}

package/packages/tarijs/src/templates/Pool.ts

@@ -0,0 +1,42 @@
+import { TariMethodDefinition, WorkspaceArg } from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+interface CreatePool extends TariMethodDefinition {
+  methodName: "create_pool";
+  args?: [string, string];
+}
+
+interface AddLiquidityMethod extends TariMethodDefinition {
+  methodName: "add_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+  methodName: "remove_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface SwapMethod extends TariMethodDefinition {
+  methodName: "swap";
+  args?: (WorkspaceArg | string)[];
+}
+
+export class PoolTemplate extends TemplateFactory {
+  public createPool: CreatePool;
+  public addLiquidity: AddLiquidityMethod;
+  public removeLiquidity: RemoveLiquidityMethod;
+  public swap: SwapMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+
+  protected _initFunctions(): void {}
+  protected _initMethods(): void {
+    this.addLiquidity = this._defineMethod<AddLiquidityMethod>("add_liquidity");
+    this.removeLiquidity = this._defineMethod<RemoveLiquidityMethod>("remove_liquidity");
+    this.swap = this._defineMethod<SwapMethod>("swap");
+  }
+}

package/packages/tarijs/src/templates/Tariswap.ts

@@ -0,0 +1,101 @@
+import {
+  Amount,
+  ConfidentialWithdrawProof,
+  ResourceAddress,
+  TariFunctionDefinition,
+  TariMethodDefinition,
+  WorkspaceArg,
+} from "@tari-project/tarijs-builders";
+import { TemplateFactory } from "./TemplateFactory";
+
+interface NewPoolFunction extends TariFunctionDefinition {
+  functionName: "new";
+  args?: [ResourceAddress, ResourceAddress, Amount];
+}
+
+interface MintFunction extends TariFunctionDefinition {
+  functionName: "mint";
+  args?: [Amount];
+}
+
+interface MintWithSymbolFunction extends TariFunctionDefinition {
+  functionName: "mint_with_symbol";
+  args?: [Amount, string];
+}
+
+interface PayFeeMethod extends TariMethodDefinition {
+  methodName: "pay_fee";
+  args?: [string];
+}
+
+interface PayFeeConfidentialMethod extends TariMethodDefinition {
+  methodName: "pay_fee_confidential";
+  args?: [ConfidentialWithdrawProof];
+}
+
+interface TotalSupplyMethod extends TariMethodDefinition {
+  methodName: "total_supply";
+  args?: [];
+}
+
+interface WithdrawMethod extends TariMethodDefinition {
+  methodName: "withdraw";
+  args?: [string, string];
+}
+
+interface AddLiquidityMethod extends TariMethodDefinition {
+  methodName: "add_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface RemoveLiquidityMethod extends TariMethodDefinition {
+  methodName: "remove_liquidity";
+  args?: WorkspaceArg[];
+}
+
+interface DepositMethod extends TariMethodDefinition {
+  methodName: "deposit";
+  args?: WorkspaceArg[];
+}
+
+interface SwapMethod extends TariMethodDefinition {
+  methodName: "swap";
+  args?: (WorkspaceArg | string)[];
+}
+
+export class TariswapTemplate extends TemplateFactory {
+  public newPool: NewPoolFunction;
+  public mint: MintFunction;
+  public mintWithSymbol: MintWithSymbolFunction;
+  public totalSupply: TotalSupplyMethod;
+  public payFee: PayFeeMethod;
+  public payFeeConfidential: PayFeeConfidentialMethod;
+  public withdraw: WithdrawMethod;
+  public addLiquidity: AddLiquidityMethod;
+  public removeLiquidity: RemoveLiquidityMethod;
+  public deposit: DepositMethod;
+  public swap: SwapMethod;
+
+  constructor(public templateAddress: string) {
+    super(templateAddress);
+    this._initFunctions();
+    this._initMethods();
+  }
+
+  protected _initFunctions(): void {
+    this.newPool = this._defineFunction<NewPoolFunction>("new");
+    this.mint = this._defineFunction<MintFunction>("mint");
+    this.mintWithSymbol = this._defineFunction<MintWithSymbolFunction>("mint_with_symbol");
+  }
+
+  protected _initMethods(): void {
+    this.totalSupply = this._defineMethod<TotalSupplyMethod>("total_supply");
+    this.payFee = this._defineMethod<PayFeeMethod>("pay_fee");
+    this.payFeeConfidential = this._defineMethod<PayFeeConfidentialMethod>("pay_fee_confidential");
+    this.withdraw = this._defineMethod<WithdrawMethod>("withdraw");
+    this.addLiquidity = this._defineMethod<AddLiquidityMethod>("add_liquidity");
+    this.removeLiquidity = this._defineMethod<RemoveLiquidityMethod>("remove_liquidity");
+    this.deposit = this._defineMethod<DepositMethod>("deposit");
+    this.swap = this._defineMethod<SwapMethod>("swap");
+  }
+}