@tari-project/tarijs 0.4.2 → 0.5.1

package/packages/tari_universe/src/utils.ts

@@ -1,16 +1,16 @@
-import { ProviderMethodNames, ProviderRequest, ProviderResponse, ProviderReturnType } from "./types";
+import { SignerMethodNames, SignerRequest, SignerResponse, SignerReturnType } from "./types";
 
-export function sendProviderCall<MethodName extends ProviderMethodNames>(
-  req: Omit<ProviderRequest<MethodName>, "id">,
+export function sendSignerCall<MethodName extends SignerMethodNames>(
+  req: Omit<SignerRequest<MethodName>, "id">,
   id: number,
-): Promise<ProviderReturnType<MethodName>> {
-  return new Promise<ProviderReturnType<MethodName>>((resolve, reject) => {
-    const event_ref = (resp: MessageEvent<ProviderResponse<MethodName>>) => {
+): Promise<SignerReturnType<MethodName>> {
+  return new Promise<SignerReturnType<MethodName>>((resolve, reject) => {
+    const event_ref = (resp: MessageEvent<SignerResponse<MethodName>>) => {
       if (resp.data.resultError) {
         window.removeEventListener("message", event_ref);
         reject(resp.data.resultError);
       }
-      if (resp && resp.data && resp.data.id && resp.data.id === id && resp.data.type === "provider-call") {
+      if (resp && resp.data && resp.data.id && resp.data.id === id && resp.data.type === "signer-call") {
         window.removeEventListener("message", event_ref);
         resolve(resp.data.result);
       }
@@ -18,6 +18,6 @@ export function sendProviderCall<MethodName extends ProviderMethodNames>(
 
     window.addEventListener("message", event_ref, false);
 
-    window.parent.postMessage({ ...req, id, type: "provider-call" }, "*");
+    window.parent.postMessage({ ...req, id, type: "signer-call" }, "*");
   });
 }

package/packages/tari_universe/tsconfig.json

@@ -7,15 +7,13 @@
     "outDir": "./dist",
     "rootDir": "./src"
   },
-  "include": [
-    "src/**/*"
-  ],
+  "include": ["src/**/*"],
   "references": [
     {
       "path": "../tari_permissions"
     },
     {
-      "path": "../tari_provider"
+      "path": "../tari_signer"
     },
     {
       "path": "../tarijs_types"

package/packages/tarijs/integration-tests/wallet_daemon/json_rpc_provider.spec.ts

@@ -1,36 +1,36 @@
 import { assert, describe, expect, it } from "vitest";
 
-import { SubmitTransactionRequest, TariPermissions, WalletDaemonTariProvider } from "../../src";
+import { SubmitTransactionRequest, TariPermissions, WalletDaemonTariSigner } from "../../src";
 
-function buildProvider(): Promise<WalletDaemonTariProvider> {
+function buildSigner(): Promise<WalletDaemonTariSigner> {
   const permissions = new TariPermissions().addPermission("Admin");
   const serverUrl = process.env.WALLET_DAEMON_JSON_RPC_URL;
   assert(serverUrl, "WALLET_DAEMON_JSON_RPC_URL must be set");
-  return WalletDaemonTariProvider.buildFetchProvider({
+  return WalletDaemonTariSigner.buildFetchSigner({
     permissions,
     serverUrl,
   });
 }
 
-describe("WalletDaemonTariProvider", () => {
-  describe("providerName", () => {
-    it("returns the provider name", async () => {
-      const provider = await buildProvider();
-      expect(provider.providerName).toBe("WalletDaemon");
+describe("WalletDaemonTariSigner", () => {
+  describe("signerName", () => {
+    it("returns the signer name", async () => {
+      const signer = await buildSigner();
+      expect(signer.signerName).toBe("WalletDaemon");
     });
   });
 
   describe("isConnected", () => {
     it("is always connected", async () => {
-      const provider = await buildProvider();
-      expect(provider.isConnected()).toBe(true);
+      const signer = await buildSigner();
+      expect(signer.isConnected()).toBe(true);
     });
   });
 
   describe("getAccount", () => {
     it("returns account information", async () => {
-      const provider = await buildProvider();
-      const account = await provider.getAccount();
+      const signer = await buildSigner();
+      const account = await signer.getAccount();
 
       expect(account).toMatchObject({
         account_id: expect.any(Number),
@@ -42,10 +42,10 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("getSubstate", () => {
     it("returns substate details", async () => {
-      const provider = await buildProvider();
-      const listedSubstates = await provider.listSubstates(null, null, 1, 0);
+      const signer = await buildSigner();
+      const listedSubstates = await signer.listSubstates(null, null, 1, 0);
       const firstSubstate = listedSubstates.substates[0];
-      const substate = await provider.getSubstate(firstSubstate.substate_id);
+      const substate = await signer.getSubstate(firstSubstate.substate_id);
 
       expect(substate).toMatchObject({
         value: expect.any(Object),
@@ -59,10 +59,10 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("getTransactionResult", () => {
     it("returns transaction result", async () => {
-      const provider = await buildProvider();
+      const signer = await buildSigner();
 
       const id = "d5f5a26e7272b1bba7bed331179e555e28c40d92ba3cde1e9ba2b4316e50f486";
-      const txResult = await provider.getTransactionResult(id);
+      const txResult = await signer.getTransactionResult(id);
       expect(txResult).toMatchObject({
         transaction_id: id,
       });
@@ -71,21 +71,21 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("submitTransaction", () => {
     it("submits a transaction", async () => {
-      const provider = await buildProvider();
+      const signer = await buildSigner();
 
-      const account = await provider.getAccount();
+      const account = await signer.getAccount();
 
       const fee = 2000;
       const fee_instructions = [
-          {
-              CallMethod: {
-                  component_address: account.address,
-                  method: "pay_fee",
-                  args: [`Amount(${fee})`]
-              }
-          }
+        {
+          CallMethod: {
+            component_address: account.address,
+            method: "pay_fee",
+            args: [`Amount(${fee})`],
+          },
+        },
       ];
-      
+
       const request: SubmitTransactionRequest = {
         network: 0x10, // LocalNet
         account_id: account.account_id,
@@ -100,7 +100,7 @@ describe("WalletDaemonTariProvider", () => {
         is_seal_signer_authorized: true,
         detect_inputs_use_unversioned: true,
       };
-      const result = await provider.submitTransaction(request);
+      const result = await signer.submitTransaction(request);
 
       expect(result).toMatchObject({
         transaction_id: expect.any(String),
@@ -110,10 +110,10 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("getAccountBalances", () => {
     it("returns account balances", async () => {
-      const provider = await buildProvider();
+      const signer = await buildSigner();
 
-      const account = await provider.getAccount();
-      const accountBalances = await provider.getAccountBalances(account.address);
+      const account = await signer.getAccount();
+      const accountBalances = await signer.getAccountBalances(account.address);
 
       expect(accountBalances).toHaveProperty("address");
 
@@ -139,22 +139,22 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("getTemplateDefinition", () => {
     it("returns template definition", async () => {
-      const provider = await buildProvider();
+      const signer = await buildSigner();
       const accountTemplateAddress = "0000000000000000000000000000000000000000000000000000000000000000";
-      const templateDefinition = await provider.getTemplateDefinition(accountTemplateAddress);
+      const templateDefinition = await signer.getTemplateDefinition(accountTemplateAddress);
 
       expect(templateDefinition).toMatchObject({
         V1: {
           functions: expect.any(Array),
-        }
+        },
       });
     });
   });
 
   describe("getPublicKey", () => {
     it("returns public key", async () => {
-      const provider = await buildProvider();
-      const publicKey = await provider.getPublicKey("transaction", 0);
+      const signer = await buildSigner();
+      const publicKey = await signer.getPublicKey("transaction", 0);
 
       expect(publicKey).toEqual(expect.any(String));
     });
@@ -162,28 +162,28 @@ describe("WalletDaemonTariProvider", () => {
 
   describe("listSubstates", () => {
     it("returns substates", async () => {
-      const provider = await buildProvider();
-      const { substates } = await provider.listSubstates(null, null, 10, 0);
+      const signer = await buildSigner();
+      const { substates } = await signer.listSubstates(null, null, 10, 0);
 
       expect(substates.length).toBeGreaterThan(0);
     });
 
     it("filters substates by template address", async () => {
-      const provider = await buildProvider();
-      const { substates } = await provider.listSubstates(null, null, 10, 0);
+      const signer = await buildSigner();
+      const { substates } = await signer.listSubstates(null, null, 10, 0);
 
       const substateWithTemplate = substates.find((substate) => substate.template_address);
       assert(substateWithTemplate, "No substate with template found");
 
-      const templateAddress = substateWithTemplate.template_address
-      const { substates: filteredSubstates } = await provider.listSubstates(templateAddress, null, 10, 0);
+      const templateAddress = substateWithTemplate.template_address;
+      const { substates: filteredSubstates } = await signer.listSubstates(templateAddress, null, 10, 0);
 
       expect(filteredSubstates.every((substate) => substate.template_address === templateAddress)).toBe(true);
     });
 
     it("filters substates by type", async () => {
-      const provider = await buildProvider();
-      const { substates } = await provider.listSubstates(null, "Component", 10, 0);
+      const signer = await buildSigner();
+      const { substates } = await signer.listSubstates(null, "Component", 10, 0);
 
       expect(substates.every((substate) => substate.module_name)).toBe(true);
     });

package/packages/tarijs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -16,15 +16,17 @@
   "license": "ISC",
   "dependencies": {
     "@metamask/providers": "catalog:",
-    "@tari-project/metamask-provider": "workspace:^",
+    "@tari-project/metamask-signer": "workspace:^",
     "@tari-project/tari-permissions": "workspace:^",
-    "@tari-project/tari-provider": "workspace:^",
-    "@tari-project/tari-universe-provider": "workspace:^",
+    "@tari-project/tari-signer": "workspace:^",
+    "@tari-project/tari-universe-signer": "workspace:^",
     "@tari-project/tarijs-builders": "workspace:^",
     "@tari-project/tarijs-types": "workspace:^",
     "@tari-project/typescript-bindings": "catalog:",
-    "@tari-project/wallet-connect-provider": "workspace:^",
-    "@tari-project/wallet-daemon-provider": "workspace:^"
+    "@tari-project/wallet-connect-signer": "workspace:^",
+    "@tari-project/wallet-daemon-signer": "workspace:^",
+    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/indexer-provider": "workspace:^"
   },
   "devDependencies": {
     "@types/node": "catalog:",

package/packages/tarijs/src/index.ts

@@ -1,28 +1,13 @@
+import { TariSigner } from "@tari-project/tari-signer";
 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 { 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,
@@ -34,38 +19,64 @@ import {
 } 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,
+  TransactionStatus,
+  GetTransactionResultResponse,
+  AccountData,
+  SubmitTransactionResponse,
+  SubmitTransactionRequest,
+  VaultBalances,
+  VaultData,
+  TemplateDefinition,
+  SubstateRequirement,
+  Substate,
+} from "@tari-project/tarijs-types";
 
 export * from "@tari-project/tarijs-types";
 export {
   utils,
   Network,
+  TariSigner,
   TariProvider,
-  Account,
+  AccountData,
   TransactionStatus,
-  TransactionResult,
+  GetTransactionResultResponse,
   SubmitTransactionResponse,
   SubmitTransactionRequest,
   VaultBalances,
   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.1",
   "description": "",
   "type": "module",
   "publishConfig": {

package/packages/tarijs_types/src/ConfidentialOutput.ts

@@ -1,4 +1,4 @@
-import type { ElgamalVerifiableBalance } from "./ElgamalVerifiableBalance";
+import { ElgamalVerifiableBalance } from "@tari-project/typescript-bindings";
 
 export interface ConfidentialOutput {
   commitment: string;

package/packages/tarijs_types/src/ConfidentialWithdrawProof.ts

@@ -1,4 +1,4 @@
-import type { ConfidentialOutputStatement } from "./ConfidentialOutputStatement";
+import { ConfidentialOutputStatement } from "@tari-project/typescript-bindings";
 
 export interface ConfidentialWithdrawProof {
   inputs: Array<Uint8Array>;

package/packages/tarijs_types/src/GetTransactionResultResponse.ts

@@ -0,0 +1,8 @@
+import { FinalizeResult } from "@tari-project/typescript-bindings";
+import { TransactionStatus } from "./TransactionStatus";
+
+export type GetTransactionResultResponse = {
+  transaction_id: string;
+  status: TransactionStatus;
+  result: FinalizeResult | null;
+};

package/packages/tarijs_types/src/Instruction.ts

@@ -1,9 +1,8 @@
-import { ComponentAddress, LogLevel } from "@tari-project/typescript-bindings";
-import { Arg } from "./Arg";
+import { ComponentAddress, LogLevel, PublishedTemplateAddress } from "@tari-project/typescript-bindings";
+import { TransactionArg } from "./TransactionArg";
 import { ConfidentialClaim } from "./ConfidentialClaim";
 import { Amount } from "./Amount";
 import { ConfidentialOutput } from "./ConfidentialOutput";
-import { TemplateAddress } from "./TemplateAddress";
 
 export type Instruction =
   | CreateAccount
@@ -17,8 +16,12 @@ export type Instruction =
   | CreateFreeTestCoins;
 
 export type CreateAccount = { CreateAccount: { owner_public_key: string; workspace_bucket: string | null } };
-export type CallFunction = { CallFunction: { template_address: TemplateAddress; function: string; args: Array<Arg> } };
-export type CallMethod = { CallMethod: { component_address: ComponentAddress; method: string; args: Array<Arg> } };
+export type CallFunction = {
+  CallFunction: { template_address: PublishedTemplateAddress; function: string; args: Array<TransactionArg> };
+};
+export type CallMethod = {
+  CallMethod: { component_address: ComponentAddress; method: string; args: Array<TransactionArg> };
+};
 export type PutLastInstructionOutputOnWorkspace = { PutLastInstructionOutputOnWorkspace: { key: number[] } };
 export type EmitLog = { EmitLog: { level: LogLevel; message: string } };
 export type ClaimBurn = { ClaimBurn: { claim: ConfidentialClaim } };

package/packages/tarijs_types/src/ListAccountNftFromBalancesRequest.ts

@@ -0,0 +1,5 @@
+import { BalanceEntry } from "@tari-project/typescript-bindings";
+
+export interface ListAccountNftFromBalancesRequest {
+  balances: Array<BalanceEntry>;
+}

package/packages/tarijs_types/src/Transaction.ts

@@ -1,8 +1,8 @@
 import { Instruction } from "./Instruction";
 import { SubstateRequirement } from "./SubstateRequirement";
-import { Epoch } from "./Epoch";
 import { VersionedSubstateId } from "./VersionedSubstateId";
 import { TransactionSignature } from "./TransactionSignature";
+import { Epoch } from "@tari-project/typescript-bindings";
 
 export interface Transaction {
   id: string;

package/packages/tarijs_types/src/TransactionArg.ts

@@ -0,0 +1,2 @@
+// this type differs from ts-bindings to allow any argument to be passed in the transaction
+export type TransactionArg = any;

package/packages/tarijs_types/src/TransactionResult.ts

@@ -1,3 +1,4 @@
+import { TransactionStatus } from "./TransactionStatus";
 import { FinalizeResult } from "./FinalizeResult";
 
 export type SubmitTransactionResponse = {
@@ -9,16 +10,6 @@ export interface SubmitTxResult {
   result: TransactionResult;
 }
 
-export enum TransactionStatus {
-  New,
-  DryRun,
-  Pending,
-  Accepted,
-  Rejected,
-  InvalidTransaction,
-  OnlyFeeAccepted,
-}
-
 export type TransactionResult = {
   transaction_id: string;
   status: TransactionStatus;

package/packages/tarijs_types/src/TransactionStatus.ts

@@ -0,0 +1,9 @@
+export enum TransactionStatus {
+  New,
+  DryRun,
+  Pending,
+  Accepted,
+  Rejected,
+  InvalidTransaction,
+  OnlyFeeAccepted,
+}

package/packages/tarijs_types/src/UnsignedTransaction.ts

@@ -1,9 +1,8 @@
+import { Epoch } from "@tari-project/typescript-bindings";
 import { Instruction } from "./Instruction";
-import { Epoch } from "./Epoch";
 import { SubstateRequirement } from "./SubstateRequirement";
 import { VersionedSubstateId } from "./VersionedSubstateId";
 
-//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
 // differs from bindings implementation because of 'Instruction'
 export interface UnsignedTransaction {
   feeInstructions: Instruction[];

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

@@ -0,0 +1,69 @@
+import { NonFungibleId, NonFungibleToken, ResourceAddress } from "@tari-project/typescript-bindings";
+import { TransactionStatus } from "../TransactionStatus";
+export {
+  substateIdToString,
+  stringToSubstateId,
+  shortenSubstateId,
+  shortenString,
+  rejectReasonToString,
+  getSubstateDiffFromTransactionResult,
+  getRejectReasonFromTransactionResult,
+  jrpcPermissionToString,
+} from "@tari-project/typescript-bindings";
+
+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;
+}