@tari-project/tarijs 0.4.1 → 0.5.0

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

@@ -1,3 +1,4 @@
+import { TariSigner } from "@tari-project/tari-signer";
 import { TariProvider } from "@tari-project/tari-provider";
 import * as utils from "./utils";
 import { Network } from "./network";
@@ -12,17 +13,13 @@ import {
   TemplateDefinition,
   SubstateRequirement,
   Substate,
-} from "@tari-project/tari-provider";
-import { MetamaskTariProvider } from "@tari-project/metamask-provider";
+} from "@tari-project/tari-signer";
+import { MetamaskTariSigner } from "@tari-project/metamask-signer";
 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 { WalletDaemonTariSigner, WalletDaemonParameters, TariPermissions } from "@tari-project/wallet-daemon-signer";
+import { TariUniverseSigner, TariUniverseSignerParameters } from "@tari-project/tari-universe-signer";
 import * as permissions from "@tari-project/tari-permissions";
-import { WalletConnectTariProvider } from "@tari-project/wallet-connect-provider";
+import { WalletConnectTariSigner } from "@tari-project/wallet-connect-signer";
 import {
   TransactionBuilder,
   TransactionRequest,
@@ -33,11 +30,21 @@ import {
   toWorkspace,
 } from "@tari-project/tarijs-builders";
 import * as templates from "./templates";
+import { parseCbor, getCborValueByPath } from "./cbor";
+import { IndexerProvider, IndexerProviderParameters } from "@tari-project/indexer-provider";
+import {
+  convertStringToTransactionStatus,
+  convertHexStringToU256Array,
+  convertU256ToHexString,
+  createNftAddressFromResource,
+  createNftAddressFromToken,
+} from "@tari-project/tarijs-types";
 
 export * from "@tari-project/tarijs-types";
 export {
   utils,
   Network,
+  TariSigner,
   TariProvider,
   Account,
   TransactionStatus,
@@ -48,22 +55,31 @@ export {
   VaultData,
   TemplateDefinition,
   SubstateRequirement,
-  MetamaskTariProvider,
-  WalletDaemonTariProvider,
+  MetamaskTariSigner,
+  WalletDaemonTariSigner,
   WalletDaemonParameters,
-  TariUniverseProvider,
-  TariUniverseProviderParameters,
+  TariUniverseSigner,
+  TariUniverseSignerParameters,
   TariPermissions,
   MetaMaskInpageProvider,
   Substate,
-  permissions,
-  WalletConnectTariProvider,
+  WalletConnectTariSigner,
   TransactionBuilder,
   TransactionRequest,
+  IndexerProvider,
+  IndexerProviderParameters,
+  convertStringToTransactionStatus,
   buildTransactionRequest,
   submitAndWaitForTransaction,
   waitForTransactionResult,
   fromWorkspace,
   toWorkspace,
+  convertHexStringToU256Array,
+  convertU256ToHexString,
+  createNftAddressFromResource,
+  createNftAddressFromToken,
+  permissions,
   templates,
+  parseCbor,
+  getCborValueByPath,
 };

package/packages/tarijs/tsconfig.json

@@ -15,7 +15,10 @@
       "path": "../builders"
     },
     {
-      "path": "../metamask_provider"
+      "path": "../indexer_provider"
+    },
+    {
+      "path": "../metamask_signer"
     },
     {
       "path": "../tari_permissions"
@@ -23,6 +26,9 @@
     {
       "path": "../tari_provider"
     },
+    {
+      "path": "../tari_signer"
+    },
     {
       "path": "../tari_universe"
     },

package/packages/tarijs_types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs-types",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "publishConfig": {

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

@@ -0,0 +1,62 @@
+import { NonFungibleId, NonFungibleToken, ResourceAddress } from "@tari-project/typescript-bindings";
+import { TransactionStatus } from "../TransactionResult";
+
+export function convertStringToTransactionStatus(status: string): TransactionStatus {
+  switch (status) {
+    case "New":
+      return TransactionStatus.New;
+    case "DryRun":
+      return TransactionStatus.DryRun;
+    case "Pending":
+      return TransactionStatus.Pending;
+    case "Accepted":
+      return TransactionStatus.Accepted;
+    case "Rejected":
+      return TransactionStatus.Rejected;
+    case "InvalidTransaction":
+      return TransactionStatus.InvalidTransaction;
+    case "OnlyFeeAccepted":
+      return TransactionStatus.OnlyFeeAccepted;
+    default:
+      throw new Error(`Unknown status: ${status}`);
+  }
+}
+
+// Function to create the Nft address
+// address format: nft_RESOURCEADDR_uuid_TOKENID
+export function createNftAddressFromToken(token: NonFungibleToken): string {
+  return createNftAddressFromResource(token.resource_address, token.nft_id);
+}
+
+export function convertU256ToHexString(id: NonFungibleId): string {
+  if ("U256" in id && Array.isArray(id.U256)) {
+    return id.U256.map((num) => num.toString(16).padStart(2, "0")).join("");
+  }
+  return "";
+}
+
+export function convertHexStringToU256Array(hexString: string): number[] {
+  const cleanHexString = hexString.replace(/[^0-9a-fA-F]/g, "");
+  const u256Array: number[] = [];
+
+  for (let i = 0; i < cleanHexString.length; i += 2) {
+    const hexPair = cleanHexString.slice(i, i + 2);
+    u256Array.push(parseInt(hexPair, 16));
+  }
+
+  return u256Array;
+}
+
+export function createNftAddressFromResource(address: ResourceAddress, tokenId: NonFungibleId): string {
+  let nftAddress = "nft_";
+
+  const resourceAddress = address.replace(/^resource_/, "");
+  nftAddress += resourceAddress;
+
+  nftAddress += "_uuid_";
+
+  const nftIdHexString = convertU256ToHexString(tokenId);
+  nftAddress += nftIdHexString;
+
+  return nftAddress;
+}

package/packages/tarijs_types/src/index.ts

@@ -9,7 +9,11 @@ export { ConfidentialStatement } from "./ConfidentialStatement";
 export { ConfidentialWithdrawProof } from "./ConfidentialWithdrawProof";
 export { Epoch } from "./Epoch";
 export {
-  FinalizeResult, FinalizeResultStatus, TxResultAccept, TxResultAcceptFeeRejectRest, TxResultReject,
+  FinalizeResult,
+  FinalizeResultStatus,
+  TxResultAccept,
+  TxResultAcceptFeeRejectRest,
+  TxResultReject,
 } from "./FinalizeResult";
 export { ResourceAddress } from "./ResourceAddress";
 export { Instruction } from "./Instruction";
@@ -23,3 +27,10 @@ export { UnsignedTransaction } from "./UnsignedTransaction";
 export { VersionedSubstateId } from "./VersionedSubstateId";
 export { ViewableBalanceProof } from "./ViewableBalanceProof";
 export { WorkspaceArg } from "./Workspace";
+export {
+  convertHexStringToU256Array,
+  convertStringToTransactionStatus,
+  convertU256ToHexString,
+  createNftAddressFromResource,
+  createNftAddressFromToken,
+} from "./helpers";

package/packages/wallet_daemon/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "@tari-project/wallet-daemon-provider",
-  "version": "0.4.0",
+  "name": "@tari-project/wallet-daemon-signer",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -14,7 +14,8 @@
   "license": "ISC",
   "dependencies": {
     "@tari-project/tari-permissions": "workspace:^",
-    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/tari-signer": "workspace:^",
+    "@tari-project/tarijs-types": "workspace:^",
     "@tari-project/wallet_jrpc_client": "catalog:"
   },
   "devDependencies": {

package/packages/wallet_daemon/src/index.ts

@@ -2,4 +2,4 @@ export { TariConnection } from "./webrtc";
 
 
 export * from "@tari-project/tari-permissions";
-export * from "./provider";
+export * from "./signer";