@tari-project/tarijs 0.4.0 → 0.4.1

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)"

package/packages/walletconnect/package.json

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

package/packages/walletconnect/src/index.ts

@@ -0,0 +1,274 @@
+import {
+  TariProvider, SubmitTransactionRequest,
+  TransactionResult,
+  SubmitTransactionResponse,
+  VaultBalances, TemplateDefinition, Substate,
+  Account,
+  ListSubstatesResponse,
+} from "@tari-project/tari-provider";
+import {
+  TransactionStatus,
+} from "@tari-project/tarijs-builders";
+import UniversalProvider from "@walletconnect/universal-provider";
+import { WalletConnectModal } from "@walletconnect/modal";
+import {
+  Instruction,
+  KeyBranch,
+  stringToSubstateId,
+  substateIdToString,
+  SubstateType,
+  TransactionSubmitRequest,
+} from "@tari-project/wallet_jrpc_client";
+
+const walletConnectParams = {
+  requiredNamespaces: {
+    tari: {
+      methods: [
+        "tari_getSubstate",
+        "tari_getDefaultAccount",
+        "tari_getAccountBalances",
+        "tari_submitTransaction",
+        "tari_getTransactionResult",
+        "tari_getTemplate",
+        "tari_createKey",
+        "tari_viewConfidentialVaultBalance",
+        "tari_createFreeTestCoins",
+        "tari_listSubstates",
+      ],
+      chains: [
+        "tari:devnet",
+      ],
+      events: ["chainChanged\", \"accountsChanged"],
+    },
+  },
+};
+
+export class WalletConnectTariProvider implements TariProvider {
+  public providerName = "WalletConnect";
+  projectId: string;
+  wcProvider: UniversalProvider | null;
+  wcSession: any | null;
+
+  constructor(projectId: string) {
+    this.projectId = projectId;
+    this.wcProvider = null;
+    this.wcSession = null;
+  }
+
+  async connect(): Promise<void> {
+    if (this.wcProvider && this.wcSession)
+      return;
+
+    // initialize WalletConnect
+    const projectId = this.projectId;
+    this.wcProvider = await UniversalProvider.init({
+      projectId,
+      // TODO: parameterize the relay URL
+      relayUrl: "wss://relay.walletconnect.com",
+    });
+
+    // open UI modal with the connection URI
+    const { uri, approval } = await this.wcProvider.client.connect(walletConnectParams);
+    const walletConnectModal = new WalletConnectModal({
+      projectId,
+    });
+    if (uri) {
+      walletConnectModal.openModal({ uri });
+    }
+
+    // wait for the wallet to approve the connection
+    console.log("waiting for session approval from the wallet app");
+    const session = await approval();
+    walletConnectModal.closeModal();
+
+    // at this point session is open
+    console.log("session approved by the wallet");
+    this.wcSession = session;
+  }
+
+  private async sendRequest(method: string, params: object): Promise<any> {
+    if (!this.wcProvider) {
+      throw "WalletConnect provider not initialized";
+    }
+
+    if (!this.wcSession) {
+      throw "WalletConnect session not initialized";
+    }
+
+    const requestResult = await this.wcProvider.client.request({
+      topic: this.wcSession.topic,
+      chainId: "tari:devnet",
+      request: {
+        method,
+        params,
+      },
+    });
+
+    console.log({ requestResult });
+
+    return requestResult;
+  }
+
+
+  isConnected(): boolean {
+    // TODO: check status in the session
+    return this.wcSession !== null;
+  }
+
+  async getAccount(): Promise<Account> {
+    const { account, public_key } = await this.sendRequest("tari_getDefaultAccount", {});
+    const { balances } = await this.sendRequest(
+      "tari_getAccountBalances",
+      {
+        account: { ComponentAddress: account.address }, refresh: false,
+      });
+
+    return {
+      account_id: account.key_index,
+      address: account.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,
+      })),
+    };
+  }
+
+  async getSubstate(substate_address: string): Promise<Substate> {
+    const method = "tari_getSubstate";
+    const params = { substate_id: substate_address };
+    const { value, record } = await this.sendRequest(method, params);
+    return {
+      value,
+      address: {
+        substate_id: record.substate_id,
+        version: record.version,
+      },
+    };
+  }
+
+  public async listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse> {
+    const method = "tari_listSubstates";
+    const params = {
+      filter_by_template,
+      filter_by_type,
+      limit,
+      offset,
+    };
+    const res = await this.sendRequest(method, params);
+    const substates = res.substates.map((s: any) => ({
+      substate_id: substateIdToString(s.substate_id),
+      module_name: s.module_name,
+      version: s.version,
+      template_address: s.template_address,
+    }));
+
+    return { substates };
+  }
+
+  public async createFreeTestCoins(): Promise<Account> {
+    const method = "tari_createFreeTestCoins";
+    const params = {
+      account: { Name: "template_web" },
+      amount: 1000000,
+      max_fee: null,
+      key_id: 0,
+    };
+    const res = await this.sendRequest(method, params);
+    return {
+      account_id: res.account.key_index,
+      address: (res.account.address as { Component: string }).Component,
+      public_key: res.public_key,
+      resources: [],
+    };
+  }
+
+  async submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse> {
+    const method = "tari_submitTransaction";
+    const params: TransactionSubmitRequest = {
+      transaction: {
+        V1: {
+          network: req.network,
+          fee_instructions: req.fee_instructions as Instruction[],
+          instructions: req.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.sendRequest(method, params);
+
+    return { transaction_id: res.transaction_id };
+  }
+
+  async getTransactionResult(transactionId: string): Promise<TransactionResult> {
+    const res = await this.sendRequest("tari_getTransactionResult", { transaction_id: transactionId });
+
+    return {
+      transaction_id: transactionId,
+      status: convertStringToTransactionStatus(res.status),
+      result: res.result,
+    };
+  }
+
+  async getTemplateDefinition(template_address: string): Promise<TemplateDefinition> {
+    let resp = await this.sendRequest("tari_getTemplate", { template_address });
+    return resp.template_definition as TemplateDefinition;
+  }
+
+  async getPublicKey(branch: string, index: number): Promise<string> {
+    const res = await this.sendRequest("tari_createKey", { branch: branch as KeyBranch, specific_index: index });
+    return res.public_key;
+  }
+
+  async getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min: number | null, max: number | null): Promise<VaultBalances> {
+    const method = "tari_viewConfidentialVaultBalance";
+    const params = {
+      view_key_id: viewKeyId,
+      vault_id: vaultId,
+      minimum_expected_value: min,
+      maximum_expected_value: max,
+    };
+
+    const res = await this.sendRequest(method, params);
+    return { balances: res.balances as unknown as Map<string, number | null> };
+  }
+
+}
+
+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/walletconnect/tsconfig.json

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

package/pnpm-workspace.yaml

@@ -0,0 +1,14 @@
+packages:
+  - packages/*
+  - apps/*
+  - "!**/test/**"
+catalog:
+  typescript: ^5.0.4
+  vitest: ^3.0.4
+  vite: ^6.1.0
+  "@types/node": ^22.13.1
+  "@tari-project/typescript-bindings": ^1.4.0
+  "@tari-project/wallet_jrpc_client": ^1.4.0
+  "@metamask/providers": ^18.2.0
+  "@walletconnect/universal-provider": ^2.13.3
+  "@walletconnect/modal": ^2.6.2