@tari-project/tarijs 0.4.0 → 0.4.2

package/packages/wallet_daemon/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/wallet_daemon/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@tari-project/wallet-daemon-provider",
+  "version": "0.4.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/wallet_jrpc_client": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}

package/packages/wallet_daemon/src/index.ts

@@ -0,0 +1,5 @@
+export { TariConnection } from "./webrtc";
+
+
+export * from "@tari-project/tari-permissions";
+export * from "./provider";

package/packages/wallet_daemon/src/provider.ts

@@ -0,0 +1,263 @@
+import { TariPermissions } from "@tari-project/tari-permissions";
+import { TariConnection } from "./webrtc";
+import { TariProvider } from "@tari-project/tari-provider";
+import {
+  SubmitTransactionRequest,
+  TransactionResult,
+  TransactionStatus,
+  SubmitTransactionResponse,
+  VaultBalances, TemplateDefinition, Substate,
+  ListSubstatesResponse,
+} from "@tari-project/tari-provider";
+import { Account } from "@tari-project/tari-provider";
+import {
+  WalletDaemonClient,
+  substateIdToString,
+  Instruction,
+  SubstateType,
+  SubstatesListRequest,
+  KeyBranch,
+  SubstateId,
+} from "@tari-project/wallet_jrpc_client";
+import { WebRtcRpcTransport } from "./webrtc_transport";
+
+export const WalletDaemonNotConnected = "WALLET_DAEMON_NOT_CONNECTED";
+export const Unsupported = "UNSUPPORTED";
+
+export interface WalletDaemonBaseParameters {
+  permissions: TariPermissions,
+  optionalPermissions?: TariPermissions,
+  onConnection?: () => void
+}
+
+export interface WalletDaemonParameters extends WalletDaemonBaseParameters {
+  signalingServerUrl?: string,
+  webRtcConfig?: RTCConfiguration,
+  name?: string,
+};
+
+export interface WalletDaemonFetchParameters extends WalletDaemonBaseParameters {
+  serverUrl: string,
+}
+
+export class WalletDaemonTariProvider implements TariProvider {
+  public providerName = "WalletDaemon";
+  params: WalletDaemonParameters;
+  client: WalletDaemonClient;
+
+  private constructor(params: WalletDaemonParameters, connection: WalletDaemonClient) {
+    this.params = params;
+    this.client = connection;
+  }
+
+  static async build(params: WalletDaemonParameters): Promise<WalletDaemonTariProvider> {
+    const allPermissions = WalletDaemonTariProvider.buildPermissions(params);
+    let connection = new TariConnection(params.signalingServerUrl, params.webRtcConfig);
+    const client = WalletDaemonClient.new(WebRtcRpcTransport.new(connection));
+    await connection.init(allPermissions, (conn) => {
+      params.onConnection?.();
+      if (conn.token) {
+        client.setToken(conn.token);
+      }
+    });
+    return new WalletDaemonTariProvider(params, client);
+  }
+
+  static async buildFetchProvider(params: WalletDaemonFetchParameters) {
+    const allPermissions = WalletDaemonTariProvider.buildPermissions(params);
+    const client = WalletDaemonClient.usingFetchTransport(params.serverUrl);
+
+    const plainPermissions = allPermissions.toJSON().flatMap((p) => typeof (p) === "string" ? [p] : []);
+    const authResponse = await client.authRequest(plainPermissions);
+    await client.authAccept(authResponse, "WalletDaemon");
+
+    params.onConnection?.();
+    return new WalletDaemonTariProvider(params, client);
+  }
+
+  private static buildPermissions(params: WalletDaemonBaseParameters): TariPermissions {
+    const allPermissions = new TariPermissions();
+    allPermissions.addPermissions(params.permissions);
+    if (params.optionalPermissions) {
+      allPermissions.addPermissions(params.optionalPermissions);
+    }
+    return allPermissions;
+  }
+
+  private getWebRtcTransport(): WebRtcRpcTransport | undefined {
+    const transport = this.client.getTransport();
+    return transport instanceof WebRtcRpcTransport ? transport : undefined;
+  }
+
+  public get token(): string | undefined {
+    return this.getWebRtcTransport()?.token();
+  }
+
+  public get tokenUrl(): string | undefined {
+    if (!this.token) {
+      return undefined;
+    }
+
+    const name = this.params.name && encodeURIComponent(this.params.name) || "";
+    const token = this.token;
+    const permissions = JSON.stringify(this.params.permissions);
+    const optionalPermissions = JSON.stringify(this.params.optionalPermissions);
+
+    return `tari://${name}/${token}/${permissions}/${optionalPermissions}`;
+  }
+
+  public isConnected(): boolean {
+    return this.getWebRtcTransport()?.isConnected() || true;
+  }
+
+  public async createFreeTestCoins(): Promise<Account> {
+    const res = await this.client.createFreeTestCoins({
+      account: { Name: "template_web" },
+      amount: 1000000,
+      max_fee: null,
+      key_id: 0,
+    });
+    return {
+      account_id: res.account.key_index,
+      address: (res.account.address as { Component: string }).Component,
+      public_key: res.public_key,
+      resources: [],
+    };
+  }
+
+  public async getAccount(): Promise<Account> {
+    const { account, public_key } = await this.client.accountsGetDefault({}) as any;
+    const address = typeof account.address === "object" ? account.address.Component : account.address;
+    const { balances } = await this.client.accountsGetBalances({
+      account: { ComponentAddress: address },
+      refresh: false,
+    });
+
+    return {
+      account_id: account.key_index,
+      address,
+      public_key,
+      // TODO: should be vaults not resources
+      resources: balances.map((b: any) => ({
+        type: b.resource_type,
+        resource_address: b.resource_address,
+        balance: b.balance + b.confidential_balance,
+        vault_id: (typeof (b.vault_address) === "object" && "Vault" in b.vault_address) ? b.vault_address.Vault : b.vault_address,
+        token_symbol: b.token_symbol,
+      })),
+    };
+  }
+
+  public async getAccountBalances(componentAddress: string): Promise<unknown> {
+    return await this.client.accountsGetBalances({ account: { ComponentAddress: componentAddress }, refresh: true });
+  }
+
+  public async getSubstate(substateId: string): Promise<Substate> {
+    // Wallet daemon expects a SubstateId as a string
+    const { value, record } = await this.client.substatesGet({ substate_id: substateId as unknown as SubstateId });
+    return {
+      value,
+      address: {
+        substate_id: substateIdToString(record.substate_id),
+        version: record.version,
+      },
+    };
+  }
+
+  public async submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse> {
+    const params = {
+      transaction: {
+        V1: {
+          network: req.network,
+          instructions: req.instructions as Instruction[],
+          fee_instructions: req.fee_instructions as Instruction[],
+          inputs: req.required_substates.map((s) => ({
+            // TODO: Hmm The bindings want a SubstateId object, but the wallet only wants a string. Any is used to skip type checking here
+            substate_id: s.substate_id as any,
+            version: s.version ?? null,
+          })),
+          min_epoch: null,
+          max_epoch: null,
+          is_seal_signer_authorized: req.is_seal_signer_authorized,
+        },
+      },
+      signing_key_index: req.account_id,
+      autofill_inputs: [],
+      detect_inputs: true,
+      proof_ids: [],
+      detect_inputs_use_unversioned: req.detect_inputs_use_unversioned,
+    };
+
+    const res = await this.client.submitTransaction(params);
+    return { transaction_id: res.transaction_id };
+  }
+
+  public async getTransactionResult(transactionId: string): Promise<TransactionResult> {
+    const res = await this.client.getTransactionResult({ transaction_id: transactionId });
+
+    return {
+      transaction_id: transactionId,
+      status: convertStringToTransactionStatus(res.status),
+      result: res.result,
+    };
+  }
+
+  public async getPublicKey(branch: string, index: number): Promise<string> {
+    const res = await this.client.createKey({ branch: branch as KeyBranch, specific_index: index });
+    return res.public_key;
+  }
+
+  public async getTemplateDefinition(template_address: string): Promise<TemplateDefinition> {
+    let resp = await this.client.templatesGet({ template_address });
+    return resp.template_definition as TemplateDefinition;
+  }
+
+  public async getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min: number | null = null, max: number | null = null): Promise<VaultBalances> {
+    const res = await this.client.viewVaultBalance({
+      view_key_id: viewKeyId,
+      vault_id: vaultId,
+      minimum_expected_value: min,
+      maximum_expected_value: max,
+    });
+    return { balances: res.balances as unknown as Map<string, number | null> };
+  }
+
+  public async listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse> {
+    const resp = await this.client.substatesList({
+      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 };
+  }
+}
+
+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}`);
+  }
+}

package/packages/wallet_daemon/src/webrtc.ts

@@ -0,0 +1,229 @@
+import { TariPermissions } from "@tari-project/tari-permissions";
+import { transports } from "@tari-project/wallet_jrpc_client";
+
+class SignaligServer {
+  private _token?: string;
+  private _server_url: string;
+
+  constructor(server_url: string | undefined) {
+    console.log(server_url);
+    if (server_url !== undefined) {
+      this._server_url = server_url;
+    } else {
+      this._server_url = "http://localhost:9100";
+    }
+  }
+
+  async initToken(permissions: TariPermissions) {
+    this._token = await this.authLogin(permissions);
+  }
+
+  public get token() {
+    return this._token;
+  }
+
+  private async jsonRpc(method: string, token?: string, params?: any) {
+    console.log("jsonRpc", method, token, params);
+    let id = 0;
+    id += 1;
+    let address = this._server_url;
+    let headers: { [key: string]: string } = { "Content-Type": "application/json" };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    let response = await fetch(address, {
+      method: "POST",
+      body: JSON.stringify({
+        method: method,
+        jsonrpc: "2.0",
+        id: id,
+        params: params || {},
+      }),
+      headers: headers,
+    });
+    let json = await response.json();
+    if (json.error) {
+      throw json.error;
+    }
+    return json.result;
+  }
+
+  private async authLogin(permissions: TariPermissions) {
+    return await this.jsonRpc("auth.login", undefined, permissions);
+  }
+
+  async storeIceCandidate(ice_candidate: RTCIceCandidate) {
+    return await this.jsonRpc("add.offer_ice_candidate", this._token, ice_candidate);
+  }
+
+  async storeOffer(offer: RTCSessionDescriptionInit) {
+    return await this.jsonRpc("add.offer", this._token, offer.sdp);
+  }
+
+  async getAnswer() {
+    return await this.jsonRpc("get.answer", this._token);
+  }
+
+  async getIceCandidates() {
+    return await this.jsonRpc("get.answer_ice_candidates", this._token);
+  }
+}
+
+export class TariConnection {
+  private _peerConnection: RTCPeerConnection;
+  private _dataChannel: RTCDataChannel;
+  private _signalingServer: SignaligServer;
+  private _callbacks: { [key: string]: any[] };
+  private _offer?: RTCSessionDescriptionInit;
+  private _walletToken: string | undefined;
+  // This is public so that user can directly set the onopen callback that will be called once the data channel is open.
+  public onopen: (() => void) | undefined;
+  public onConnection: ((conn: TariConnection) => void) | undefined;
+
+  constructor(signalig_server_url?: string, config?: RTCConfiguration) {
+    this._peerConnection = new RTCPeerConnection(config || this.config());
+    this._dataChannel = this._peerConnection.createDataChannel("tari-data");
+    this._signalingServer = new SignaligServer(signalig_server_url);
+    this._callbacks = {};
+  }
+
+  public get token() {
+    if (this._walletToken) {
+      return this._walletToken;
+    }
+    return this._signalingServer.token;
+  }
+
+  async init(permissions: TariPermissions, onConnection: ((conn: TariConnection) => void) | undefined) {
+    this.onConnection = onConnection;
+    await this._signalingServer.initToken(permissions);
+    // Setup our receiving end
+    this._dataChannel.onmessage = (message) => {
+      let response = JSON.parse(message.data);
+      console.log("response", response);
+
+      if (!this._callbacks[response.id]) {
+        console.error("No callback found for id", response.id);
+        return;
+      }
+      // The response should contain id, to identify the Promise.resolve, that is waiting for this result
+      let [resolve, reject] = this._callbacks[response.id];
+      delete this._callbacks[response.id];
+      if (response.payload?.error) {
+        reject(new Error(response.payload.error));
+      } else {
+        resolve(response.payload);
+      }
+    };
+    this._dataChannel.onopen = () => {
+      // This should be removed before the release, but it's good for debugging.
+      console.log("Data channel is open!");
+
+      this.sendMessage({ id: 0, jsonrpc: "2.0", method: "get.token", params: {} }, this._signalingServer.token)
+        .then((walletToken: unknown) => {
+          if (typeof walletToken !== "string") {
+            throw Error("Received invalid JWT from wallet daemon");
+          }
+
+          console.log("Wallet JWT received: ", walletToken);
+          this._walletToken = walletToken;
+
+          if (this.onConnection) {
+            this.onConnection(this);
+          }
+        });
+    };
+    this._peerConnection.onicecandidate = (event) => {
+      console.log("event", event);
+      if (event?.candidate) {
+        console.log("ICE ", event.candidate);
+        console.log("ICE ", typeof event.candidate);
+        // Store the ice candidates, so the other end can add them
+        this._signalingServer.storeIceCandidate(event.candidate).then((resp) => {
+          // This should be removed before the release, but it's good for debugging.
+          console.log("Candidate stored", resp);
+        });
+      }
+    };
+    // Create offer
+    this._offer = await this._peerConnection.createOffer();
+    // Set the offer as our local sdp, at this point it will start getting the ice candidates
+    this._peerConnection.setLocalDescription(this._offer);
+    // Store the offer so the other end can set it as a remote sdp
+    this._signalingServer.storeOffer(this._offer).then((resp) => {
+      // This should be removed before the release, but it's good for debugging.
+      console.log("Offer stored", resp);
+    });
+    await this.signalingServerPolling();
+  }
+
+  private async setAnswer() {
+    // This is called once the other end got the offer and ices and created and store an answer and its ice candidates
+    // We get its answer sdp
+    let sdp = await this._signalingServer.getAnswer();
+
+    // And its ice candidates
+    let iceCandidates = await this._signalingServer.getIceCandidates();
+
+    // For us the answer is remote sdp
+    let answer = new RTCSessionDescription({ sdp, type: "answer" });
+    this._peerConnection.setRemoteDescription(answer);
+
+    // We add all the ice candidates to connect, the other end is doing the same with our ice candidates
+    for (const iceCandidate of iceCandidates) {
+      this._peerConnection.addIceCandidate(iceCandidate);
+    }
+  }
+
+  private async signalingServerPolling() {
+    // no need to keep retrying if we are already connected to the wallet
+    if (this._peerConnection.connectionState === "connected") {
+      return;
+    }
+
+    try {
+      await this.setAnswer();
+    } catch (error) {
+      // we don't need to do anything on error, as the execution will be retried later
+      console.error(error);
+    }
+
+    // try again later
+    setTimeout(async () => {
+      await this.signalingServerPolling();
+    }, 2000);
+  }
+
+  public isConnected() {
+    return this._dataChannel.readyState === "open";
+  }
+
+  // If the last parameter has timeout property e.g. {timeout:1000}, it set the timeout for this call.
+  async sendMessage<T>(request: transports.RpcRequest, token: string | undefined, timeout_secs: number | null = null): Promise<T> {
+    if (!this.isConnected) {
+      throw new Error("WALLET_DAEMON_NOT_CONNECTED");
+    }
+
+    // This should be removed before the release, but it's good for debugging.
+    console.log(request, "timeout", timeout_secs);
+    return new Promise((resolve, reject) => {
+      // We store the resolve callback for this request,
+      // so once the data channel receives a response we know where to return the data
+      this._callbacks[request.id] = [resolve, reject];
+      if (timeout_secs) {
+        // If the user set a timeout which set it here so the promise will be rejected if not fulfilled in time.
+        setTimeout(() => {
+          delete this._callbacks[request.id];
+          reject(new Error("Timeout"));
+        }, timeout_secs * 1000);
+      }
+      // Make the actual call to the wallet daemon
+      this._dataChannel.send(JSON.stringify({ token, ...request }));
+    });
+  }
+
+  // This is our default config, use can set their own stun/turn server in the constructor.
+  private config() {
+    return { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] };
+  }
+}

package/packages/wallet_daemon/src/webrtc_transport.ts

@@ -0,0 +1,27 @@
+import {transports} from "@tari-project/wallet_jrpc_client";
+import {TariConnection} from "./webrtc";
+
+export class WebRtcRpcTransport implements transports.RpcTransport {
+    connection: TariConnection;
+
+    constructor(connection: TariConnection) {
+        this.connection = connection;
+    }
+
+    static new(connection: TariConnection) {
+        return new WebRtcRpcTransport(connection);
+    }
+
+    token(): string | undefined {
+        return this.connection.token;
+    }
+
+    isConnected(): boolean {
+        return this.connection.isConnected();
+    }
+
+    sendRequest<T>(data: transports.RpcRequest, options: transports.RpcTransportOptions): Promise<T> {
+        return this.connection.sendMessage<T>(data, options.token);
+    }
+}
+

package/packages/wallet_daemon/tsconfig.json

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

package/packages/walletconnect/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)"