@tari-project/tarijs 0.3.1 → 0.4.1

package/packages/tarijs_types/src/FinalizeResult.ts

@@ -0,0 +1,17 @@
+import { FeeReceipt, InstructionResult, LogEntry, RejectReason } from "@tari-project/typescript-bindings";
+import { SubstateDiff } from "./SubstateDiff";
+
+export type TxResultAccept = { Accept: SubstateDiff };
+export type TxResultAcceptFeeRejectRest = { AcceptFeeRejectRest: [SubstateDiff, RejectReason] };
+export type TxResultReject = { Reject: RejectReason };
+
+export type FinalizeResultStatus = TxResultAccept | TxResultAcceptFeeRejectRest | TxResultReject;
+
+export interface FinalizeResult {
+  transaction_hash: Uint8Array;
+  events: Array<Event>;
+  logs: Array<LogEntry>;
+  execution_results: Array<InstructionResult>;
+  result: FinalizeResultStatus;
+  fee_receipt: FeeReceipt;
+}

package/packages/tarijs_types/src/Instruction.ts

@@ -0,0 +1,29 @@
+import { ComponentAddress, LogLevel } from "@tari-project/typescript-bindings";
+import { Arg } from "./Arg";
+import { ConfidentialClaim } from "./ConfidentialClaim";
+import { Amount } from "./Amount";
+import { ConfidentialOutput } from "./ConfidentialOutput";
+import { TemplateAddress } from "./TemplateAddress";
+
+export type Instruction =
+  | CreateAccount
+  | CallFunction
+  | CallMethod
+  | PutLastInstructionOutputOnWorkspace
+  | EmitLog
+  | ClaimBurn
+  | ClaimValidatorFees
+  | DropAllProofsInWorkspace
+  | CreateFreeTestCoins;
+
+export type CreateAccount = { CreateAccount: { owner_public_key: string; workspace_bucket: string | null } };
+export type CallFunction = { CallFunction: { template_address: TemplateAddress; function: string; args: Array<Arg> } };
+export type CallMethod = { CallMethod: { component_address: ComponentAddress; method: string; args: Array<Arg> } };
+export type PutLastInstructionOutputOnWorkspace = { PutLastInstructionOutputOnWorkspace: { key: number[] } };
+export type EmitLog = { EmitLog: { level: LogLevel; message: string } };
+export type ClaimBurn = { ClaimBurn: { claim: ConfidentialClaim } };
+export type ClaimValidatorFees = { ClaimValidatorFees: { epoch: number; validator_public_key: string } };
+export type DropAllProofsInWorkspace = "DropAllProofsInWorkspace";
+export type CreateFreeTestCoins = {
+  CreateFreeTestCoins: { revealed_amount: Amount; output: ConfidentialOutput | null };
+};

package/{dist/builders/types/ResourceAddress.js → packages/tarijs_types/src/ResourceAddress.ts}

@@ -1,2 +1,3 @@
 //TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
-export {};
+
+export type ResourceAddress = string;

package/{dist/builders/types/SubstateDiff.d.ts → packages/tarijs_types/src/SubstateDiff.ts}

@@ -1,7 +1,9 @@
 import { Substate, SubstateId } from "@tari-project/typescript-bindings";
+
 export type UpSubstates = Array<[SubstateId, Substate]>;
 export type DownSubstates = Array<[SubstateId, number]>;
+
 export interface SubstateDiff {
-    up_substates: UpSubstates;
-    down_substates: DownSubstates;
+  up_substates: UpSubstates;
+  down_substates: DownSubstates;
 }

package/{dist/builders/types/SubstateRequirement.d.ts → packages/tarijs_types/src/SubstateRequirement.ts}

@@ -1,5 +1,6 @@
 import { SubstateId } from "@tari-project/typescript-bindings";
+
 export interface SubstateRequirement {
-    substateId: SubstateId;
-    version?: number;
+  substateId: SubstateId;
+  version?: number;
 }

package/{dist/builders/types/TemplateAddress.js → packages/tarijs_types/src/TemplateAddress.ts}

@@ -1,2 +1,3 @@
 //TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
-export {};
+
+export type TemplateAddress = string;

package/{dist/builders/types/Transaction.d.ts → packages/tarijs_types/src/Transaction.ts}

@@ -3,13 +3,14 @@ import { SubstateRequirement } from "./SubstateRequirement";
 import { Epoch } from "./Epoch";
 import { VersionedSubstateId } from "./VersionedSubstateId";
 import { TransactionSignature } from "./TransactionSignature";
+
 export interface Transaction {
-    id: string;
-    feeInstructions: Array<Instruction>;
-    instructions: Array<Instruction>;
-    inputs: Array<SubstateRequirement>;
-    minEpoch?: Epoch;
-    maxEpoch?: Epoch;
-    signatures: Array<TransactionSignature>;
-    filledInputs: Array<VersionedSubstateId>;
+  id: string;
+  feeInstructions: Array<Instruction>;
+  instructions: Array<Instruction>;
+  inputs: Array<SubstateRequirement>;
+  minEpoch?: Epoch;
+  maxEpoch?: Epoch;
+  signatures: Array<TransactionSignature>;
+  filledInputs: Array<VersionedSubstateId>;
 }

package/packages/tarijs_types/src/TransactionId.ts

@@ -0,0 +1,4 @@
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+// for now ts type is string, but rust is different
+// dan_layer/transaction/src/transaction.rs
+export type TransactionId = string;

package/packages/tarijs_types/src/TransactionResult.ts

@@ -0,0 +1,26 @@
+import { FinalizeResult } from "./FinalizeResult";
+
+export type SubmitTransactionResponse = {
+  transaction_id: string;
+};
+
+export interface SubmitTxResult {
+  response: SubmitTransactionResponse;
+  result: TransactionResult;
+}
+
+export enum TransactionStatus {
+  New,
+  DryRun,
+  Pending,
+  Accepted,
+  Rejected,
+  InvalidTransaction,
+  OnlyFeeAccepted,
+}
+
+export type TransactionResult = {
+  transaction_id: string;
+  status: TransactionStatus;
+  result: FinalizeResult | null;
+};

package/packages/tarijs_types/src/TransactionSignature.ts

@@ -0,0 +1,4 @@
+export interface TransactionSignature {
+  public_key: string;
+  signature: string;
+}

package/packages/tarijs_types/src/UnsignedTransaction.ts

@@ -0,0 +1,15 @@
+import { Instruction } from "./Instruction";
+import { Epoch } from "./Epoch";
+import { SubstateRequirement } from "./SubstateRequirement";
+import { VersionedSubstateId } from "./VersionedSubstateId";
+
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+// differs from bindings implementation because of 'Instruction'
+export interface UnsignedTransaction {
+  feeInstructions: Instruction[];
+  instructions: Instruction[];
+  inputs: SubstateRequirement[];
+  filledInputs: VersionedSubstateId[];
+  minEpoch?: Epoch;
+  maxEpoch?: Epoch;
+}

package/{dist/builders/types/VersionedSubstateId.d.ts → packages/tarijs_types/src/VersionedSubstateId.ts}

@@ -1,5 +1,6 @@
 import { SubstateId } from "@tari-project/typescript-bindings";
+
 export interface VersionedSubstateId {
-    substateId: SubstateId;
-    version: number;
+  substateId: SubstateId;
+  version: number;
 }

package/packages/tarijs_types/src/ViewableBalanceProof.ts

@@ -0,0 +1,12 @@
+//TODO refactor type (https://github.com/tari-project/tari.js/issues/29)
+
+export interface ViewableBalanceProof {
+  elgamal_encrypted: Uint8Array;
+  elgamal_public_nonce: Uint8Array;
+  c_prime: Uint8Array;
+  e_prime: Uint8Array;
+  r_prime: Uint8Array;
+  s_v: Uint8Array;
+  s_m: Uint8Array;
+  s_r: Uint8Array;
+}

package/{dist/builders/types/Workspace.d.ts → packages/tarijs_types/src/Workspace.ts}

@@ -1,3 +1,3 @@
 export interface WorkspaceArg {
-    Workspace: number[];
+  Workspace: number[];
 }

package/{dist/builders/types/index.d.ts → packages/tarijs_types/src/index.ts}

@@ -1,4 +1,3 @@
-export { Builder, TariCreateAccountDefinition, TariFunctionDefinition, TariMethodDefinition, TransactionConstructor, } from "./Builder";
 export { TemplateAddress } from "./TemplateAddress";
 export { Amount } from "./Amount";
 export { Arg } from "./Arg";
@@ -9,14 +8,16 @@ export { ConfidentialOutputStatement } from "./ConfidentialOutputStatement";
 export { ConfidentialStatement } from "./ConfidentialStatement";
 export { ConfidentialWithdrawProof } from "./ConfidentialWithdrawProof";
 export { Epoch } from "./Epoch";
-export { FinalizeResult, FinalizeResultStatus } from "./FinalizeResult";
+export {
+  FinalizeResult, FinalizeResultStatus, TxResultAccept, TxResultAcceptFeeRejectRest, TxResultReject,
+} from "./FinalizeResult";
 export { ResourceAddress } from "./ResourceAddress";
 export { Instruction } from "./Instruction";
 export { Transaction } from "./Transaction";
 export { SubstateDiff, DownSubstates, UpSubstates } from "./SubstateDiff";
 export { SubstateRequirement } from "./SubstateRequirement";
 export { TransactionId } from "./TransactionId";
-export { TransactionResult, TransactionStatus } from "./TransactionResult";
+export { TransactionResult, TransactionStatus, SubmitTxResult, SubmitTransactionResponse } from "./TransactionResult";
 export { TransactionSignature } from "./TransactionSignature";
 export { UnsignedTransaction } from "./UnsignedTransaction";
 export { VersionedSubstateId } from "./VersionedSubstateId";

package/packages/tarijs_types/tsconfig.json

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

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/{dist/providers/wallet_daemon/index.d.ts → packages/wallet_daemon/src/index.ts}

@@ -1,3 +1,5 @@
 export { TariConnection } from "./webrtc";
-export * from "./tari_permissions";
+
+
+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}`);
+  }
+}