@tari-project/tarijs 0.4.2 → 0.5.1

package/packages/indexer_provider/src/provider.ts

@@ -0,0 +1,105 @@
+import { TariProvider } 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,
+  GetSubstateRequest,
+  GetTransactionResultResponse,
+  ListSubstatesRequest,
+  ListSubstatesResponse,
+  Substate,
+} 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<GetTransactionResultResponse> {
+    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.1",
   "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,18 @@ import {
   TemplateDefinition,
   Substate,
   ListSubstatesResponse,
-  Account
-} from "@tari-project/tari-provider";
+  AccountData,
+  ListSubstatesRequest,
+  GetTransactionResultResponse,
+} from "@tari-project/tarijs-types";
 import { MetaMaskInpageProvider } from "@metamask/providers";
 import { connectSnap, getSnap, isFlask, Snap } from "./utils";
-import { SubstateType } from "@tari-project/typescript-bindings";
+import {
+  ConfidentialViewVaultBalanceRequest,
+  ListAccountNftRequest,
+  ListAccountNftResponse,
+  SubstateType,
+} from "@tari-project/typescript-bindings";
 
 export const MetamaskNotInstalled = "METAMASK_NOT_INSTALLED";
 export const MetamaskIsNotFlask = "METAMASK_IS_NOT_FLASK";
@@ -20,8 +27,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;
@@ -64,7 +71,7 @@ export class MetamaskTariProvider implements TariProvider {
     return this.metamaskConnected;
   }
 
-  public async createFreeTestCoins(account_id: number): Promise<Account> {
+  public async createFreeTestCoins(account_id: number): Promise<AccountData> {
     const res = (await this.metamaskRequest("getFreeTestCoins", {
       amount: 1000000,
       account_id,
@@ -78,7 +85,7 @@ export class MetamaskTariProvider implements TariProvider {
     };
   }
 
-  async getAccount(): Promise<Account> {
+  async getAccount(): Promise<AccountData> {
     return (await this.metamaskRequest("getAccountData", { account_id: 0 })) as any;
   }
 
@@ -91,12 +98,12 @@ export class MetamaskTariProvider implements TariProvider {
     return { value: substate, address: { substate_id, version } };
   }
 
-  async listSubstates(
-    filter_by_template: string | null,
-    filter_by_type: SubstateType | null,
-    limit: number | null,
-    offset: number | null,
-  ): Promise<ListSubstatesResponse> {
+  async listSubstates({
+    filter_by_template,
+    filter_by_type,
+    limit,
+    offset,
+  }: ListSubstatesRequest): Promise<ListSubstatesResponse> {
     const res = (await this.metamaskRequest("listSubstates", {
       filter_by_template,
       filter_by_type,
@@ -126,7 +133,7 @@ export class MetamaskTariProvider implements TariProvider {
     return { transaction_id: resp.transaction_id };
   }
 
-  public async getTransactionResult(transactionId: string): Promise<TransactionResult> {
+  public async getTransactionResult(transactionId: string): Promise<GetTransactionResultResponse> {
     // This request returns the response from the indexer get_transaction_result request
     const resp: Maybe<any> = await this.metamaskRequest("getTransactionResult", { transaction_id: transactionId });
 
@@ -139,7 +146,7 @@ export class MetamaskTariProvider implements TariProvider {
         transaction_id: transactionId,
         status: TransactionStatus.Pending,
         result: null,
-      } as TransactionResult;
+      } as GetTransactionResultResponse;
     }
 
     if (!resp?.result?.Finalized) {
@@ -152,7 +159,7 @@ export class MetamaskTariProvider implements TariProvider {
       transaction_id: transactionId,
       status: newStatus,
       result: resp.result.Finalized.execution_result.finalize,
-    } as TransactionResult;
+    } as GetTransactionResultResponse;
   }
 
   public async getPublicKey(_branch: string, index: number): Promise<string> {
@@ -165,20 +172,20 @@ export class MetamaskTariProvider implements TariProvider {
     return resp.public_key;
   }
 
-  public async getConfidentialVaultBalances(
-    viewKeyId: number,
-    vaultId: string,
-    min: number | null = null,
-    max: number | null = null,
-  ): Promise<VaultBalances> {
-    const res = (await this.metamaskRequest("getConfidentialVaultBalances", {
-      view_key_id: viewKeyId,
-      vault_id: vaultId,
-      minimum_expected_value: min,
-      maximum_expected_value: max,
-    })) as any;
+  public async getConfidentialVaultBalances({
+    vault_id,
+    maximum_expected_value,
+    minimum_expected_value,
+    view_key_id,
+  }: ConfidentialViewVaultBalanceRequest): Promise<VaultBalances> {
+    const resp = await this.metamaskRequest("getConfidentialVaultBalances", {
+      view_key_id,
+      vault_id,
+      minimum_expected_value,
+      maximum_expected_value,
+    });
 
-    return { balances: res as unknown as Map<string, number | null> };
+    return { balances: resp as Map<string, number | null> };
   }
 
   getTemplateDefinition(template_address: string): Promise<TemplateDefinition> {
@@ -212,6 +219,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.1",
   "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";