@tari-project/tarijs 0.4.1 → 0.5.0

package/packages/tari_universe/src/{provider.ts → signer.ts}

@@ -6,25 +6,30 @@ import {
   VaultBalances,
   ListSubstatesResponse,
   SubmitTransactionRequest,
-  TariProvider,
-  TransactionResult
-} from "@tari-project/tari-provider";
+  TariSigner,
+  TransactionResult,
+} from "@tari-project/tari-signer";
 import {
-  ProviderRequest,
-  ProviderMethodNames,
-  ProviderReturnType,
-  TariUniverseProviderParameters,
+  SignerRequest,
+  SignerMethodNames,
+  SignerReturnType,
+  TariUniverseSignerParameters,
   WindowSize,
+  ListAccountNftFromBalancesRequest,
 } from "./types";
-import {  } from "@tari-project/tari-provider";
-import { AccountsGetBalancesResponse, SubstateType } from "@tari-project/wallet_jrpc_client";
-import { sendProviderCall } from "./utils";
-
-export class TariUniverseProvider implements TariProvider {
-  public providerName = "TariUniverse";
+import {
+  AccountsGetBalancesResponse,
+  ListAccountNftRequest,
+  ListAccountNftResponse,
+  SubstateType,
+} from "@tari-project/wallet_jrpc_client";
+import { sendSignerCall } from "./utils";
+
+export class TariUniverseSigner implements TariSigner {
+  public signerName = "TariUniverse";
   private __id = 0;
 
-  public constructor(public params: TariUniverseProviderParameters) {
+  public constructor(public params: TariUniverseSignerParameters) {
     const filterResizeEvent = function (event: MessageEvent) {
       if (event.data && event.data.type === "resize") {
         const resizeEvent = new CustomEvent("resize", {
@@ -36,11 +41,11 @@ export class TariUniverseProvider implements TariProvider {
     window.addEventListener("message", (event) => filterResizeEvent(event), false);
   }
 
-  private async sendRequest<MethodName extends ProviderMethodNames>(
-    req: Omit<ProviderRequest<MethodName>, "id">,
-  ): Promise<ProviderReturnType<MethodName>> {
+  private async sendRequest<MethodName extends SignerMethodNames>(
+    req: Omit<SignerRequest<MethodName>, "id">,
+  ): Promise<SignerReturnType<MethodName>> {
     const id = ++this.__id;
-    return sendProviderCall(req, id);
+    return sendSignerCall(req, id);
   }
 
   public isConnected(): boolean {
@@ -84,21 +89,7 @@ export class TariUniverseProvider implements TariProvider {
   }
 
   public async getAccount(): Promise<Account> {
-    const { account_id, address, public_key } = await this.sendRequest({ methodName: "getAccount", args: [] });
-    const { balances } = await this.getAccountBalances(address);
-
-    return {
-      account_id,
-      address,
-      public_key,
-      resources: balances.map((b: any) => ({
-        type: b.resource_type,
-        resource_address: b.resource_address,
-        balance: b.balance + b.confidential_balance,
-        vault_id: "Vault" in b.vault_address ? b.vault_address.Vault : b.vault_address,
-        token_symbol: b.token_symbol,
-      })),
-    };
+    return this.sendRequest({ methodName: "getAccount", args: [] });
   }
 
   public async getAccountBalances(componentAddress: string): Promise<AccountsGetBalancesResponse> {
@@ -132,4 +123,12 @@ export class TariUniverseProvider implements TariProvider {
   public async getTemplateDefinition(template_address: string): Promise<TemplateDefinition> {
     return this.sendRequest({ methodName: "getTemplateDefinition", args: [template_address] });
   }
+
+  public async getNftsList(req: ListAccountNftRequest): Promise<ListAccountNftResponse> {
+    return this.sendRequest({ methodName: "getNftsList", args: [req] });
+  }
+
+  public async getNftsFromAccountBalances(req: ListAccountNftFromBalancesRequest): Promise<ListAccountNftResponse> {
+    return this.sendRequest({ methodName: "getNftsFromAccountBalances", args: [req] });
+  }
 }

package/packages/tari_universe/src/types.ts

@@ -1,7 +1,8 @@
 import { TariPermissions } from "@tari-project/tari-permissions";
-import { TariUniverseProvider } from "./provider";
+import { TariUniverseSigner } from "./signer";
+import { BalanceEntry } from "@tari-project/typescript-bindings";
 
-export type TariUniverseProviderParameters = {
+export type TariUniverseSignerParameters = {
   permissions: TariPermissions;
   optionalPermissions: TariPermissions;
   name?: string;
@@ -15,19 +16,23 @@ export type WindowSize = {
 
 export type PickMatching<T, V> = { [K in keyof T as T[K] extends V ? K : never]: T[K] };
 export type ExtractMethods<T> = PickMatching<T, Function>;
-export type ProviderMethods = ExtractMethods<TariUniverseProvider>;
-export type ProviderMethodNames = keyof ProviderMethods;
-export type ProviderReturnType<T extends ProviderMethodNames> = Awaited<ReturnType<ProviderMethods[T]>>;
+export type SignerMethods = ExtractMethods<TariUniverseSigner>;
+export type SignerMethodNames = keyof SignerMethods;
+export type SignerReturnType<T extends SignerMethodNames> = Awaited<ReturnType<SignerMethods[T]>>;
 
-export type ProviderRequest<T extends ProviderMethodNames> = {
+export type SignerRequest<T extends SignerMethodNames> = {
   id: number;
   methodName: T;
-  args: Parameters<ProviderMethods[T]>;
+  args: Parameters<SignerMethods[T]>;
 };
 
-export type ProviderResponse<T extends ProviderMethodNames> = {
+export type SignerResponse<T extends SignerMethodNames> = {
   id: number;
-  type: "provider-call";
-  result: ProviderReturnType<T>;
+  type: "signer-call";
+  result: SignerReturnType<T>;
   resultError?: string;
 };
+
+export interface ListAccountNftFromBalancesRequest {
+  balances: Array<BalanceEntry>;
+}

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/moon.yml

@@ -54,6 +54,14 @@ tasks:
       - "@files(configs)"
       - "@files(tests)"
   test:
+    command: "pnpm run test"
+    inputs:
+      - "@files(sources)"
+      - "@files(tests)"
+      - "@files(configs)"
+    deps:
+      - "build"
+  integration-test:
     command: "pnpm run integration-tests"
     inputs:
       - "@files(sources)"

package/packages/tarijs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -8,6 +8,7 @@
   },
   "scripts": {
     "build": "tsc -b",
+    "test": "vitest run src",
     "integration-tests": "vitest run integration-tests"
   },
   "keywords": [],
@@ -15,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:",