@tari-project/tarijs 0.4.1 → 0.5.0

package/packages/builders/src/helpers/submitTransaction.ts

@@ -1,5 +1,5 @@
-import { TariUniverseProvider } from "@tari-project/tari-universe-provider";
-import { TariProvider, SubmitTransactionRequest, SubstateRequirement } from "@tari-project/tari-provider";
+import { TariUniverseSigner } from "@tari-project/tari-universe-signer";
+import { TariSigner, SubmitTransactionRequest, SubstateRequirement } from "@tari-project/tari-signer";
 import {
   Transaction,
   TransactionResult,
@@ -8,7 +8,7 @@ import {
   UpSubstates,
   FinalizeResultStatus,
   TxResultAccept,
-  SubmitTxResult
+  SubmitTxResult,
 } from "@tari-project/tarijs-types";
 
 export function buildTransactionRequest(
@@ -40,12 +40,12 @@ export function buildTransactionRequest(
 }
 
 export async function submitAndWaitForTransaction(
-  provider: TariProvider,
+  signer: TariSigner,
   req: SubmitTransactionRequest,
 ): Promise<SubmitTxResult> {
   try {
-    const response = await provider.submitTransaction(req);
-    const result = await waitForTransactionResult(provider, response.transaction_id);
+    const response = await signer.submitTransaction(req);
+    const result = await waitForTransactionResult(signer, response.transaction_id);
 
     return {
       response,
@@ -57,12 +57,12 @@ export async function submitAndWaitForTransaction(
 }
 
 export async function waitForTransactionResult(
-  provider: TariProvider | TariUniverseProvider,
+  signer: TariSigner | TariUniverseSigner,
   transactionId: string,
 ): Promise<TransactionResult> {
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const resp = await provider.getTransactionResult(transactionId);
+    const resp = await signer.getTransactionResult(transactionId);
     const FINALIZED_STATUSES = [
       TransactionStatus.Accepted,
       TransactionStatus.Rejected,

package/packages/builders/tsconfig.json

@@ -7,12 +7,10 @@
     "outDir": "./dist",
     "rootDir": "./src"
   },
-  "include": [
-    "src/**/*"
-  ],
+  "include": ["src/**/*"],
   "references": [
     {
-      "path": "../tari_provider"
+      "path": "../tari_signer"
     },
     {
       "path": "../tari_universe"

package/packages/indexer_provider/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tari-project/indexer-provider",
+  "version": "0.5.0",
+  "description": "",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@tari-project/tari-permissions": "workspace:^",
+    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/tarijs-types": "workspace:^",
+    "@tari-project/typescript-bindings": "catalog:",
+    "@tari-project/wallet_jrpc_client": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}

package/packages/indexer_provider/src/index.ts

@@ -0,0 +1,2 @@
+export { IndexerProvider, IndexerProviderParameters } from "./provider";
+export * from "./transports";

package/packages/indexer_provider/src/provider.ts

@@ -0,0 +1,105 @@
+import {
+  GetSubstateRequest,
+  ListSubstatesRequest,
+  ListSubstatesResponse,
+  Substate,
+  TariProvider,
+  TransactionResult,
+} from "@tari-project/tari-provider";
+import { TariPermissions } from "@tari-project/tari-permissions";
+import { IndexerProviderClient } from "./transports";
+import {
+  GetTemplateDefinitionResponse,
+  ListTemplatesResponse,
+  stringToSubstateId,
+  substateIdToString,
+  SubstatesListRequest,
+} from "@tari-project/typescript-bindings";
+import { convertStringToTransactionStatus } from "@tari-project/tarijs-types";
+
+export interface IndexerProviderParameters {
+  indexerJrpcUrl: string;
+  permissions: TariPermissions;
+  optionalPermissions?: TariPermissions;
+  onConnection?: () => void;
+}
+
+export class IndexerProvider implements TariProvider {
+  public providerName = "IndexerProvider";
+  client: IndexerProviderClient;
+  params: IndexerProviderParameters;
+
+  private constructor(params: IndexerProviderParameters, connection: IndexerProviderClient) {
+    this.params = params;
+    this.client = connection;
+  }
+
+  static async build(params: IndexerProviderParameters) {
+    const client = IndexerProviderClient.usingFetchTransport(params.indexerJrpcUrl);
+    await client.getIdentity();
+    params.onConnection?.();
+    return new IndexerProvider(params, client);
+  }
+
+  public isConnected(): boolean {
+    return this.client.isConnected();
+  }
+
+  public async listSubstates({
+    filter_by_template,
+    filter_by_type,
+    limit,
+    offset,
+  }: ListSubstatesRequest): Promise<ListSubstatesResponse> {
+    const resp = await this.client.listSubstates({
+      filter_by_template,
+      filter_by_type,
+      limit,
+      offset,
+    } as SubstatesListRequest);
+
+    const substates = resp.substates.map((s) => ({
+      substate_id: typeof s.substate_id === "string" ? s.substate_id : substateIdToString(s.substate_id),
+      module_name: s.module_name,
+      version: s.version,
+      template_address: s.template_address,
+    }));
+
+    return { substates };
+  }
+
+  public async getSubstate({ substate_address, version }: GetSubstateRequest): Promise<Substate> {
+    const resp = await this.client.getSubstate({
+      address: stringToSubstateId(substate_address),
+      version: version ?? null,
+      local_search_only: false,
+    });
+    return {
+      address: {
+        substate_id: substateIdToString(resp.address),
+        version: resp.version,
+      },
+      value: resp.substate,
+    };
+  }
+
+  public async listTemplates(limit: number = 0): Promise<ListTemplatesResponse> {
+    const resp = await this.client.listTemplates({ limit });
+    return resp;
+  }
+
+  public async getTransactionResult(transactionId: string): Promise<TransactionResult> {
+    const resp = await this.client.getTransactionResult({ transaction_id: transactionId });
+
+    return {
+      transaction_id: transactionId,
+      status: convertStringToTransactionStatus(resp.status),
+      result: resp.result,
+    };
+  }
+
+  public async getTemplateDefinition(template_address: string): Promise<GetTemplateDefinitionResponse> {
+    let resp = await this.client.getTemplateDefinition({ template_address });
+    return resp;
+  }
+}

package/packages/indexer_provider/src/transports/IndexerProviderClient.ts

@@ -0,0 +1,144 @@
+import {
+  GetEpochManagerStatsResponse,
+  GetNonFungibleCollectionsResponse,
+  GetNonFungibleCountRequest,
+  GetNonFungibleCountResponse,
+  GetNonFungiblesRequest,
+  GetNonFungiblesResponse,
+  GetRelatedTransactionsRequest,
+  GetRelatedTransactionsResponse,
+  GetTemplateDefinitionRequest,
+  GetTemplateDefinitionResponse,
+  IndexerGetIdentityResponse,
+  IndexerGetSubstateRequest,
+  IndexerGetSubstateResponse,
+  IndexerSubmitTransactionRequest,
+  IndexerSubmitTransactionResponse,
+  InspectSubstateRequest,
+  InspectSubstateResponse,
+  ListTemplatesRequest,
+  ListTemplatesResponse,
+  SubstatesListRequest,
+  SubstatesListResponse,
+  TransactionGetResultRequest,
+  TransactionGetResultResponse,
+  TransactionWaitResultRequest,
+  TransactionWaitResultResponse,
+} from "@tari-project/typescript-bindings";
+import { FetchRpcTransport, RpcTransport } from "./rpc";
+
+export class IndexerProviderClient {
+  private token: string | null;
+  private transport: RpcTransport;
+  private id: number;
+  private connected: boolean;
+
+  constructor(transport: RpcTransport) {
+    this.token = null;
+    this.transport = transport;
+    this.id = 0;
+    this.connected = false;
+  }
+
+  public static new(transport: RpcTransport): IndexerProviderClient {
+    return new IndexerProviderClient(transport);
+  }
+
+  public static usingFetchTransport(url: string): IndexerProviderClient {
+    return IndexerProviderClient.new(FetchRpcTransport.new(url));
+  }
+
+  getTransport() {
+    return this.transport;
+  }
+
+  public isAuthenticated() {
+    return this.token !== null;
+  }
+
+  public isConnected() {
+    return this.connected;
+  }
+
+  public setToken(token: string) {
+    this.token = token;
+  }
+
+  public submitTransaction(params: IndexerSubmitTransactionRequest): Promise<IndexerSubmitTransactionResponse> {
+    return this.__invokeRpc("submit_transaction", params);
+  }
+
+  public inspectSubstate(params: InspectSubstateRequest): Promise<InspectSubstateResponse> {
+    return this.__invokeRpc("inspect_substate", params);
+  }
+
+  public getSubstate(params: IndexerGetSubstateRequest): Promise<IndexerGetSubstateResponse> {
+    return this.__invokeRpc("get_substate", params);
+  }
+
+  public listSubstates(params: SubstatesListRequest): Promise<SubstatesListResponse> {
+    return this.__invokeRpc("list_substates", params);
+  }
+
+  public listTemplates(params: ListTemplatesRequest): Promise<ListTemplatesResponse> {
+    return this.__invokeRpc("list_templates", params);
+  }
+
+  public getTemplateDefinition(params: GetTemplateDefinitionRequest): Promise<GetTemplateDefinitionResponse> {
+    return this.__invokeRpc("get_template_definition", params);
+  }
+
+  public getTransactionResult(params: TransactionGetResultRequest): Promise<TransactionGetResultResponse> {
+    return this.__invokeRpc("get_transaction_result", params);
+  }
+
+  public getSubstateTransactions(params: GetRelatedTransactionsRequest): Promise<GetRelatedTransactionsResponse> {
+    return this.__invokeRpc("get_substate_transactions", params);
+  }
+
+  public getNonFungibles(params: GetNonFungiblesRequest): Promise<GetNonFungiblesResponse> {
+    return this.__invokeRpc("get_non_fungibles", params);
+  }
+
+  public getNonFungibleCollections(): Promise<GetNonFungibleCollectionsResponse> {
+    return this.__invokeRpc("get_non_fungible_collections");
+  }
+
+  public getNonFungibleCount(params: GetNonFungibleCountRequest): Promise<GetNonFungibleCountResponse> {
+    return this.__invokeRpc("get_non_fungible_count", params);
+  }
+
+  public getEpochManagerStats(): Promise<GetEpochManagerStatsResponse> {
+    return this.__invokeRpc("get_epoch_manager_stats");
+  }
+
+  public waitForTransactionResult(params: TransactionWaitResultRequest): Promise<TransactionWaitResultResponse> {
+    return this.__invokeRpc("transactions.wait_result", params);
+  }
+
+  public async getIdentity(): Promise<IndexerGetIdentityResponse | undefined> {
+    try {
+      const res: IndexerGetIdentityResponse = await this.__invokeRpc("get_identity");
+      this.connected = !!res.public_key;
+      return res;
+    } catch (e) {
+      console.error("Failed to get Indexer identity:", e);
+      this.connected = false;
+    }
+  }
+
+  async __invokeRpc(method: string, params: object | null = null) {
+    const id = this.id++;
+    const response = await this.transport.sendRequest<any>(
+      {
+        method,
+        jsonrpc: "2.0",
+        id: id,
+        params: params || {},
+      },
+      { token: this.token ?? undefined, timeout_millis: undefined },
+    );
+
+    return response;
+  }
+}

package/packages/indexer_provider/src/transports/fetch.ts

@@ -0,0 +1,46 @@
+import { RpcRequest, RpcTransport, RpcTransportOptions } from "./rpc";
+
+export default class FetchRpcTransport implements RpcTransport {
+  private url: string;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  static new(url: string) {
+    return new FetchRpcTransport(url);
+  }
+
+  async sendRequest<T>(data: RpcRequest, options: RpcTransportOptions): Promise<T> {
+    const headers: { [key: string]: string } = {
+      "Content-Type": "application/json",
+    };
+    if (options?.token) {
+      headers["Authorization"] = `Bearer ${options.token}`;
+    }
+
+    let controller = new AbortController();
+    let signal = controller.signal;
+
+    const timeoutId = options.timeout_millis
+      ? setTimeout(() => {
+          controller.abort("Timeout");
+        }, options.timeout_millis)
+      : null;
+
+    const response = await fetch(this.url, {
+      method: "POST",
+      body: JSON.stringify(data),
+      headers,
+      signal,
+    });
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(`${json.error.code}: ${json.error.message}`);
+    }
+    return json.result;
+  }
+}

package/packages/indexer_provider/src/transports/index.ts

@@ -0,0 +1,3 @@
+export { IndexerProviderClient } from "./IndexerProviderClient";
+export * from "./fetch";
+export * from "./rpc";

package/packages/indexer_provider/src/transports/rpc.ts

@@ -0,0 +1,19 @@
+import FetchRpcTransport from "./fetch";
+
+export { FetchRpcTransport };
+
+export interface RpcTransport {
+  sendRequest<T>(request: RpcRequest, options: RpcTransportOptions): Promise<T>;
+}
+
+export interface RpcTransportOptions {
+  token?: string;
+  timeout_millis?: number;
+}
+
+export interface RpcRequest {
+  id: number;
+  jsonrpc: string;
+  method: string;
+  params: any;
+}

package/packages/indexer_provider/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "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/metamask_signer/moon.yml

@@ -0,0 +1,55 @@
+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)"

package/packages/{metamask_provider → metamask_signer}/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "@tari-project/metamask-provider",
-  "version": "0.4.0",
+  "name": "@tari-project/metamask-signer",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -14,7 +14,7 @@
   "license": "ISC",
   "dependencies": {
     "@metamask/providers": "catalog:",
-    "@tari-project/tari-provider": "workspace:^",
+    "@tari-project/tari-signer": "workspace:^",
     "@tari-project/tarijs-types": "workspace:^",
     "@tari-project/typescript-bindings": "catalog:"
   },

package/packages/{metamask_provider → metamask_signer}/src/index.ts

@@ -1,4 +1,4 @@
-import { TariProvider } from "@tari-project/tari-provider";
+import { TariSigner } from "@tari-project/tari-signer";
 import {
   SubmitTransactionRequest,
   TransactionResult,
@@ -8,11 +8,11 @@ import {
   TemplateDefinition,
   Substate,
   ListSubstatesResponse,
-  Account
-} from "@tari-project/tari-provider";
+  Account,
+} from "@tari-project/tari-signer";
 import { MetaMaskInpageProvider } from "@metamask/providers";
 import { connectSnap, getSnap, isFlask, Snap } from "./utils";
-import { SubstateType } from "@tari-project/typescript-bindings";
+import { ListAccountNftRequest, ListAccountNftResponse, SubstateType } from "@tari-project/typescript-bindings";
 
 export const MetamaskNotInstalled = "METAMASK_NOT_INSTALLED";
 export const MetamaskIsNotFlask = "METAMASK_IS_NOT_FLASK";
@@ -20,8 +20,8 @@ export const TariSnapNotInstalled = "TARI_SNAP_NOT_INSTALLED";
 
 type Maybe<T> = T | null | undefined;
 
-export class MetamaskTariProvider implements TariProvider {
-  public providerName = "Metamask";
+export class MetamaskTariSigner implements TariSigner {
+  public signerName = "Metamask";
   snapId: string;
   snapVersion: string | undefined;
   metamask: MetaMaskInpageProvider;
@@ -212,6 +212,11 @@ export class MetamaskTariProvider implements TariProvider {
 
     return resp as T;
   }
+
+  public async getNftsList(req: ListAccountNftRequest): Promise<ListAccountNftResponse> {
+    const resp = (await this.metamaskRequest("getNftsList", req)) as ListAccountNftResponse;
+    return resp;
+  }
 }
 
 function convertToStatus(result: any): TransactionStatus {

package/packages/metamask_signer/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    {
+      "path": "../tari_signer"
+    },
+    {
+      "path": "../tarijs_types"
+    }
+  ]
+}

package/packages/tari_permissions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tari-permissions",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -12,8 +12,7 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "catalog:",
     "typescript": "catalog:"

package/packages/tari_permissions/src/helpers.ts

@@ -0,0 +1,33 @@
+import {
+  TariPermission,
+  TariPermissionAccountBalance,
+  TariPermissionAccountInfo,
+  TariPermissionAccountList,
+  TariPermissionGetNft,
+  TariPermissionKeyList,
+  TariPermissionNftGetOwnershipProof,
+  TariPermissionTransactionGet,
+  TariPermissionTransactionSend,
+} from "./tari_permissions";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function createPermissionFromType(permission: any): TariPermission {
+  if (Object.prototype.hasOwnProperty.call(permission, "AccountBalance")) {
+    return new TariPermissionAccountBalance(permission.AccountBalance);
+  } else if (permission === "AccountInfo") {
+    return new TariPermissionAccountInfo();
+  } else if (Object.prototype.hasOwnProperty.call(permission, "AccountList")) {
+    return new TariPermissionAccountList(permission.AccountList);
+  } else if (permission == "KeyList") {
+    return new TariPermissionKeyList();
+  } else if (Object.prototype.hasOwnProperty.call(permission, "TransactionSend")) {
+    return new TariPermissionTransactionSend(permission.TransactionSend);
+  } else if (permission === "TransactionGet") {
+    return new TariPermissionTransactionGet();
+  } else if (Object.prototype.hasOwnProperty.call(permission, "GetNft")) {
+    return new TariPermissionGetNft(permission.GetNft);
+  } else if (Object.prototype.hasOwnProperty.call(permission, "NftGetOwnershipProof")) {
+    return new TariPermissionNftGetOwnershipProof(permission.NftGetOwnershipProof);
+  }
+  return permission;
+}

package/packages/tari_permissions/src/index.ts

@@ -1 +1,2 @@
-export * from './tari_permissions';
+export * from "./tari_permissions";
+export * from "./helpers";