@tari-project/tarijs 0.4.0 → 0.4.2

package/packages/tari_universe/src/provider.ts

@@ -0,0 +1,120 @@
+import {
+  SubmitTransactionResponse,
+  Account,
+  Substate,
+  TemplateDefinition,
+  VaultBalances,
+  ListSubstatesResponse,
+  SubmitTransactionRequest,
+  TariProvider,
+  TransactionResult,
+} from "@tari-project/tari-provider";
+import {
+  ProviderRequest,
+  ProviderMethodNames,
+  ProviderReturnType,
+  TariUniverseProviderParameters,
+  WindowSize,
+} from "./types";
+import { AccountsGetBalancesResponse, SubstateType } from "@tari-project/wallet_jrpc_client";
+import { sendProviderCall } from "./utils";
+
+export class TariUniverseProvider implements TariProvider {
+  public providerName = "TariUniverse";
+  private __id = 0;
+
+  public constructor(public params: TariUniverseProviderParameters) {
+    const filterResizeEvent = function (event: MessageEvent) {
+      if (event.data && event.data.type === "resize") {
+        const resizeEvent = new CustomEvent("resize", {
+          detail: { width: event.data.width, height: event.data.height },
+        });
+        window.dispatchEvent(resizeEvent);
+      }
+    };
+    window.addEventListener("message", (event) => filterResizeEvent(event), false);
+  }
+
+  private async sendRequest<MethodName extends ProviderMethodNames>(
+    req: Omit<ProviderRequest<MethodName>, "id">,
+  ): Promise<ProviderReturnType<MethodName>> {
+    const id = ++this.__id;
+    return sendProviderCall(req, id);
+  }
+
+  public isConnected(): boolean {
+    return true;
+  }
+
+  public getPublicKey(): Promise<string> {
+    return this.sendRequest<"getPublicKey">({ methodName: "getPublicKey", args: [] });
+  }
+
+  public async listSubstates(
+    filter_by_template: string | null,
+    filter_by_type: SubstateType | null,
+    limit: number | null,
+    offset: number | null,
+  ): Promise<ListSubstatesResponse> {
+    return this.sendRequest<"listSubstates">({
+      methodName: "listSubstates",
+      args: [filter_by_template, filter_by_type, limit, offset],
+    });
+  }
+
+  public getConfidentialVaultBalances(
+    viewKeyId: number,
+    vaultId: string,
+    min: number | null,
+    max: number | null,
+  ): Promise<VaultBalances> {
+    return this.sendRequest({
+      methodName: "getConfidentialVaultBalances",
+      args: [viewKeyId, vaultId, min, max],
+    });
+  }
+
+  public async createFreeTestCoins(): Promise<void> {
+    return this.sendRequest({ methodName: "createFreeTestCoins", args: [] });
+  }
+
+  public requestParentSize(): Promise<WindowSize> {
+    return this.sendRequest({ methodName: "requestParentSize", args: [] });
+  }
+
+  public async getAccount(): Promise<Account> {
+    return this.sendRequest({ methodName: "getAccount", args: [] });
+  }
+
+  public async getAccountBalances(componentAddress: string): Promise<AccountsGetBalancesResponse> {
+    return this.sendRequest({
+      methodName: "getAccountBalances",
+      args: [componentAddress],
+    });
+  }
+
+  public async getSubstate(substate_id: string): Promise<Substate> {
+    return this.sendRequest({
+      methodName: "getSubstate",
+      args: [substate_id],
+    });
+  }
+
+  public async submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse> {
+    return this.sendRequest({
+      methodName: "submitTransaction",
+      args: [req],
+    });
+  }
+
+  public async getTransactionResult(transactionId: string): Promise<TransactionResult> {
+    return this.sendRequest({
+      methodName: "getTransactionResult",
+      args: [transactionId],
+    });
+  }
+
+  public async getTemplateDefinition(template_address: string): Promise<TemplateDefinition> {
+    return this.sendRequest({ methodName: "getTemplateDefinition", args: [template_address] });
+  }
+}

package/packages/tari_universe/src/types.ts

@@ -0,0 +1,33 @@
+import { TariPermissions } from "@tari-project/tari-permissions";
+import { TariUniverseProvider } from "./provider";
+
+export type TariUniverseProviderParameters = {
+  permissions: TariPermissions;
+  optionalPermissions: TariPermissions;
+  name?: string;
+  onConnection?: () => void;
+};
+
+export type WindowSize = {
+  width: number;
+  height: number;
+};
+
+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 ProviderRequest<T extends ProviderMethodNames> = {
+  id: number;
+  methodName: T;
+  args: Parameters<ProviderMethods[T]>;
+};
+
+export type ProviderResponse<T extends ProviderMethodNames> = {
+  id: number;
+  type: "provider-call";
+  result: ProviderReturnType<T>;
+  resultError?: string;
+};

package/packages/tari_universe/src/utils.ts

@@ -0,0 +1,23 @@
+import { ProviderMethodNames, ProviderRequest, ProviderResponse, ProviderReturnType } from "./types";
+
+export function sendProviderCall<MethodName extends ProviderMethodNames>(
+  req: Omit<ProviderRequest<MethodName>, "id">,
+  id: number,
+): Promise<ProviderReturnType<MethodName>> {
+  return new Promise<ProviderReturnType<MethodName>>((resolve, reject) => {
+    const event_ref = (resp: MessageEvent<ProviderResponse<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") {
+        window.removeEventListener("message", event_ref);
+        resolve(resp.data.result);
+      }
+    };
+
+    window.addEventListener("message", event_ref, false);
+
+    window.parent.postMessage({ ...req, id, type: "provider-call" }, "*");
+  });
+}

package/packages/tari_universe/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_permissions"
+    },
+    {
+      "path": "../tari_provider"
+    },
+    {
+      "path": "../tarijs_types"
+    }
+  ]
+}

package/packages/tarijs/integration-tests/.env

@@ -0,0 +1 @@
+WALLET_DAEMON_JSON_RPC_URL=http://127.0.0.1:12011/json_rpc

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

@@ -0,0 +1,191 @@
+import { assert, describe, expect, it } from "vitest";
+
+import { SubmitTransactionRequest, TariPermissions, WalletDaemonTariProvider } from "../../src";
+
+function buildProvider(): Promise<WalletDaemonTariProvider> {
+  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({
+    permissions,
+    serverUrl,
+  });
+}
+
+describe("WalletDaemonTariProvider", () => {
+  describe("providerName", () => {
+    it("returns the provider name", async () => {
+      const provider = await buildProvider();
+      expect(provider.providerName).toBe("WalletDaemon");
+    });
+  });
+
+  describe("isConnected", () => {
+    it("is always connected", async () => {
+      const provider = await buildProvider();
+      expect(provider.isConnected()).toBe(true);
+    });
+  });
+
+  describe("getAccount", () => {
+    it("returns account information", async () => {
+      const provider = await buildProvider();
+      const account = await provider.getAccount();
+
+      expect(account).toMatchObject({
+        account_id: expect.any(Number),
+        address: expect.any(String),
+        public_key: expect.any(String),
+      });
+    });
+  });
+
+  describe("getSubstate", () => {
+    it("returns substate details", async () => {
+      const provider = await buildProvider();
+      const listedSubstates = await provider.listSubstates(null, null, 1, 0);
+      const firstSubstate = listedSubstates.substates[0];
+      const substate = await provider.getSubstate(firstSubstate.substate_id);
+
+      expect(substate).toMatchObject({
+        value: expect.any(Object),
+        address: {
+          substate_id: firstSubstate.substate_id,
+          version: firstSubstate.version,
+        },
+      });
+    });
+  });
+
+  describe("getTransactionResult", () => {
+    it("returns transaction result", async () => {
+      const provider = await buildProvider();
+
+      const id = "d5f5a26e7272b1bba7bed331179e555e28c40d92ba3cde1e9ba2b4316e50f486";
+      const txResult = await provider.getTransactionResult(id);
+      expect(txResult).toMatchObject({
+        transaction_id: id,
+      });
+    });
+  });
+
+  describe("submitTransaction", () => {
+    it("submits a transaction", async () => {
+      const provider = await buildProvider();
+
+      const account = await provider.getAccount();
+
+      const fee = 2000;
+      const fee_instructions = [
+          {
+              CallMethod: {
+                  component_address: account.address,
+                  method: "pay_fee",
+                  args: [`Amount(${fee})`]
+              }
+          }
+      ];
+      
+      const request: SubmitTransactionRequest = {
+        network: 0x10, // LocalNet
+        account_id: account.account_id,
+        fee_instructions,
+        instructions: [],
+        inputs: [],
+        input_refs: [],
+        required_substates: [],
+        is_dry_run: false,
+        min_epoch: null,
+        max_epoch: null,
+        is_seal_signer_authorized: true,
+        detect_inputs_use_unversioned: true,
+      };
+      const result = await provider.submitTransaction(request);
+
+      expect(result).toMatchObject({
+        transaction_id: expect.any(String),
+      });
+    });
+  });
+
+  describe("getAccountBalances", () => {
+    it("returns account balances", async () => {
+      const provider = await buildProvider();
+
+      const account = await provider.getAccount();
+      const accountBalances = await provider.getAccountBalances(account.address);
+
+      expect(accountBalances).toHaveProperty("address");
+
+      assert(
+        accountBalances &&
+          typeof accountBalances === "object" &&
+          "balances" in accountBalances &&
+          accountBalances.balances,
+        "accountBalances is not an object",
+      );
+      assert(Array.isArray(accountBalances.balances), "accountBalances.balances is not an array");
+      expect(accountBalances.balances.length).toBeGreaterThan(0);
+
+      expect(accountBalances.balances[0]).toMatchObject({
+        balance: expect.any(Number),
+        resource_address: expect.any(String),
+        resource_type: expect.any(String),
+        token_symbol: expect.any(String),
+        vault_address: expect.any(String),
+      });
+    });
+  });
+
+  describe("getTemplateDefinition", () => {
+    it("returns template definition", async () => {
+      const provider = await buildProvider();
+      const accountTemplateAddress = "0000000000000000000000000000000000000000000000000000000000000000";
+      const templateDefinition = await provider.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);
+
+      expect(publicKey).toEqual(expect.any(String));
+    });
+  });
+
+  describe("listSubstates", () => {
+    it("returns substates", async () => {
+      const provider = await buildProvider();
+      const { substates } = await provider.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 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);
+
+      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);
+
+      expect(substates.every((substate) => substate.module_name)).toBe(true);
+    });
+  });
+});

package/packages/tarijs/moon.yml

@@ -0,0 +1,71 @@
+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)"
+  test:
+    command: "pnpm run test"
+    inputs:
+      - "@files(sources)"
+      - "@files(tests)"
+      - "@files(configs)"
+    deps:
+      - "build"
+  integration-test:
+    command: "pnpm run integration-tests"
+    inputs:
+      - "@files(sources)"
+      - "@files(tests)"
+      - "@files(configs)"
+    deps:
+      - "build"

package/packages/tarijs/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tari-project/tarijs",
+  "version": "0.4.0",
+  "description": "",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run src",
+    "integration-tests": "vitest run integration-tests"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@metamask/providers": "catalog:",
+    "@tari-project/metamask-provider": "workspace:^",
+    "@tari-project/tari-permissions": "workspace:^",
+    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/tari-universe-provider": "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:^"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "vite": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}