@tari-project/tarijs 0.10.1 → 0.12.0

package/packages/tarijs_types/src/Account.ts

@@ -0,0 +1,68 @@
+import { BigAmount, ResourceAddress, ResourceType, Vault, VaultId } from "@tari-project/typescript-bindings";
+
+export interface BuiltInAccount {
+  vaults: Record<ResourceAddress, VaultSubstate>;
+}
+
+export class VaultSubstate {
+  private vaultId: VaultId;
+  private vault: Vault;
+
+  constructor(vaultId: VaultId, vault: Vault) {
+    this.vaultId = vaultId;
+    this.vault = vault;
+  }
+
+  public static new(vaultId: VaultId, vault: Vault): VaultSubstate {
+    return new VaultSubstate(vaultId, vault);
+  }
+
+  public get id(): VaultId {
+    return this.vaultId;
+  }
+
+  public get rawVault(): Vault {
+    return this.vault;
+  }
+
+  public get resourceType(): ResourceType {
+    if ("Fungible" in this.vault.resource_container) {
+      return "Fungible";
+    }
+    if ("NonFungible" in this.vault.resource_container) {
+      return "NonFungible";
+    }
+    if ("Confidential" in this.vault.resource_container) {
+      return "Confidential";
+    }
+    throw new Error("Unknown resource type in vault");
+  }
+
+  public get balance(): BigAmount {
+    if ("Fungible" in this.vault.resource_container) {
+      return BigAmount.from(this.vault.resource_container.Fungible.amount);
+    }
+    if ("NonFungible" in this.vault.resource_container) {
+      return BigAmount.from(this.vault.resource_container.NonFungible.token_ids.length);
+    }
+    if ("Confidential" in this.vault.resource_container) {
+      return BigAmount.from(this.vault.resource_container.Confidential.revealed_amount);
+    }
+    throw new Error("Unknown resource type in vault");
+  }
+
+  public get resourceAddress(): ResourceAddress {
+    if ("Fungible" in this.vault.resource_container) {
+      return this.vault.resource_container.Fungible.address;
+    }
+    if ("NonFungible" in this.vault.resource_container) {
+      return this.vault.resource_container.NonFungible.address;
+    }
+    if ("Confidential" in this.vault.resource_container) {
+      return this.vault.resource_container.Confidential.address;
+    }
+    throw new Error("Unknown resource type in vault");
+  }
+
+  // TODO: add other quality of life helpers e.g balances
+}

package/packages/tarijs_types/src/Amount.ts

@@ -7,7 +7,7 @@ export class Amount {
 
   public static readonly MAX: Amount = new Amount(Number.MAX_SAFE_INTEGER);
 
-  public static newAmount(amount: number): Amount {
+  public static new(amount: number): Amount {
     return new Amount(amount);
   }
 
@@ -110,4 +110,8 @@ export class Amount {
     }
     return this.value as number;
   }
+
+  public toJSON(): number {
+    return this.value;
+  }
 }

package/packages/tarijs_types/src/TransactionResult.ts

@@ -1,6 +1,5 @@
-import { TransactionStatus } from "./TransactionStatus";
 import { DownSubstates, UpSubstates } from "./SubstateDiff";
-import { ComponentAddress, FinalizeResult, TransactionResult } from "@tari-project/typescript-bindings";
+import { ComponentAddress, TransactionResult } from "@tari-project/typescript-bindings";
 
 export type SubmitTransactionResponse = {
   transaction_id: string;
@@ -15,9 +14,3 @@ export interface SubmitTxResult {
 
   getComponentForTemplate(templateAddress: string): ComponentAddress | null;
 }
-
-export type TransactionResultResponse = {
-  transaction_id: string;
-  status: TransactionStatus;
-  result: FinalizeResult | null;
-};

package/packages/tarijs_types/src/consts.ts

@@ -0,0 +1,3 @@
+export const ACCOUNT_TEMPLATE_ADDRESS = "0000000000000000000000000000000000000000000000000000000000000000";
+export const TARI_RESOURCE = "resource_0101010101010101010101010101010101010101010101010101010101010101";
+export const XTR = TARI_RESOURCE;

package/packages/tarijs_types/src/helpers/index.ts

@@ -1,8 +1,12 @@
 import { NonFungibleId, NonFungibleToken, ResourceAddress } from "@tari-project/typescript-bindings";
 import { TransactionStatus } from "../TransactionStatus";
+
 export { fromHexString, toHexString } from "./hexString";
 export { txResultCheck, getSubstateValueFromUpSubstates, getComponentsForTemplate } from "./txResult";
 export { BinaryTag, CborValue, convertTaggedValue, getCborValueByPath, parseCbor } from "./cbor";
+export {
+  SimpleSubstateDiff, SimpleTransactionResult, AnySubstate, UpSubstate, DownSubstate, splitOnce,
+} from "./simpleResult";
 export {
   substateIdToString,
   stringToSubstateId,

package/packages/tarijs_types/src/helpers/simpleResult.ts

@@ -0,0 +1,345 @@
+import {
+  Vault,
+  SubstateId,
+  substateIdToString,
+  ComponentHeader,
+  NonFungible,
+  RejectReason,
+  Resource,
+  Substate,
+  SubstateDiff,
+  SubstateType,
+  TransactionReceipt,
+  UnclaimedConfidentialOutput,
+  ValidatorFeePool,
+  PublishedTemplate,
+  ValidatorFeeWithdrawal,
+  PublishedTemplateAddress,
+  TransactionId,
+  FinalizeResult,
+  LogEntry,
+  Event,
+} from "@tari-project/typescript-bindings";
+import { VaultSubstate, BuiltInAccount } from "../Account";
+import { TransactionStatus } from "../TransactionStatus";
+import { Option, Some, None } from "@thames/monads";
+import { GetTransactionResultResponse } from "../GetTransactionResultResponse";
+import { parseCbor } from "../";
+import { ACCOUNT_TEMPLATE_ADDRESS } from "../consts";
+
+export class SimpleTransactionResult {
+  private readonly transaction_id: TransactionId;
+  private readonly finalizeResult: FinalizeResult;
+  private readonly _status: TransactionStatus;
+
+  constructor(transaction_id: TransactionId, status: TransactionStatus, result: FinalizeResult) {
+    this.transaction_id = transaction_id;
+    this._status = status;
+    this.finalizeResult = result;
+  }
+
+  static new(transaction_id: TransactionId, status: TransactionStatus, result: FinalizeResult): SimpleTransactionResult {
+    return new SimpleTransactionResult(transaction_id, status, result);
+  }
+
+  static fromResponse(resp: GetTransactionResultResponse): SimpleTransactionResult {
+    if (!resp.result) {
+      throw new Error("Transaction result is missing in the response");
+    }
+    return SimpleTransactionResult.new(resp.transaction_id, resp.status, resp.result);
+  }
+
+  public get transactionId(): string {
+    return this.transaction_id;
+  }
+
+  public get result(): FinalizeResult {
+    return this.finalizeResult;
+  }
+
+  public get status(): TransactionStatus {
+    return this._status;
+  }
+
+  public get logs(): LogEntry[] {
+    return this.result.logs;
+  }
+
+  public get events(): Event[] {
+    return this.result.events;
+  }
+
+  public getResultingComponents(): ComponentHeader[] {
+    return this.getNewSubstatesOfType("Component") as ComponentHeader[];
+  }
+
+  public getResultingResources(): Resource[] {
+    return this.getNewSubstatesOfType("Resource") as Resource[];
+  }
+
+  public getResultingVaults(): VaultSubstate[] {
+    const vaults = this.getUpSubstatesOfType("Vault");
+    return vaults.map((upSubstate) => VaultSubstate.new(upSubstate.id, upSubstate.substate as Vault));
+  }
+
+  public getResultingNonFungibles(): NonFungible[] {
+    return this.getNewSubstatesOfType("NonFungible") as NonFungible[];
+  }
+
+  public getTransactionReceipt(): TransactionReceipt {
+    return this.getNewSubstatesOfType("TransactionReceipt")[0]! as TransactionReceipt;
+  }
+
+  public getNewPublishedTemplates(): PublishedTemplate[] {
+    return this.getNewSubstatesOfType("Template") as PublishedTemplate[];
+  }
+
+  public getNewSubstatesOfType(type: SubstateType): AnySubstate[] {
+    const upSubstates = this.getUpSubstatesOfType(type);
+    return upSubstates.map((upSubstate) => upSubstate.substate);
+  }
+
+  public getUpSubstatesOfType(type: SubstateType): UpSubstate[] {
+    const diff = this.diff;
+    if (diff.isNone()) {
+      return [];
+    }
+    const d = diff.unwrap();
+
+    const substates = [];
+    for (const upSubstate of d.upSubstates()) {
+      if (upSubstate.type === type) {
+        substates.push(upSubstate);
+      }
+    }
+
+    return substates;
+  }
+
+  public getComponentsByTemplateAddress(templateAddress: PublishedTemplateAddress): SimpleComponent[] {
+    const diff = this.diff;
+    if (diff.isNone()) {
+      return [];
+    }
+    const d = diff.unwrap();
+
+    const components = [];
+    for (const upSubstate of d.upSubstates()) {
+      if (upSubstate.type === "Component" && (upSubstate.substate as ComponentHeader).template_address === templateAddress) {
+        components.push(SimpleComponent.new(upSubstate.id, upSubstate.version, upSubstate.substate as ComponentHeader));
+      }
+    }
+
+    return components;
+  }
+
+  public getResultingAccounts(): GetAccountsResult[] {
+    const components = this.getComponentsByTemplateAddress(ACCOUNT_TEMPLATE_ADDRESS);
+
+    const accounts = [];
+    for (const component of components) {
+      const account = component.decodeBody<BuiltInAccount>();
+      accounts.push({ substate_id: component.id, version: component.version, account });
+    }
+
+    return accounts;
+  }
+
+  /**
+   * Returns the reject reason if the whole transaction was rejected or if the fee intent was executed but the main intent rejected
+   * Otherwise returns None.
+   */
+  public get anyRejectReason(): Option<RejectReason> {
+    return this.rejected.or(this.onlyFeeAccepted.map((x) => x[1]));
+  }
+
+  public get accept(): Option<SimpleSubstateDiff> {
+    const result = this.result as any;
+    const accept = result?.result.Accept;
+    if (!accept) {
+      return None;
+    }
+
+    return Some(SimpleSubstateDiff.from(accept));
+  }
+
+  public get diff(): Option<SimpleSubstateDiff> {
+    return this.accept.or(this.onlyFeeAccepted.map((x => x[0])));
+  }
+
+  public get onlyFeeAccepted(): Option<[SimpleSubstateDiff, RejectReason]> {
+    const result = this.result;
+    if (!result || !result.result || !("AcceptFeeRejectRest" in result.result)) {
+      return None;
+    }
+
+    const [diff, reason] = result?.result.AcceptFeeRejectRest;
+    return Some([SimpleSubstateDiff.from(diff), reason]);
+  }
+
+  public get rejected(): Option<RejectReason> {
+    const result = this.result as any;
+    if (!result || !result.result) {
+      return None;
+    }
+    if (!("Reject" in result.result)) {
+      return None;
+    }
+
+    return Some(result?.result.Reject);
+  }
+}
+
+export function splitOnce(str: string, separator: string): [string, string] | null {
+  const index = str.indexOf(separator);
+  if (index === -1) {
+    return null;
+  }
+  return [str.slice(0, index), str.slice(index + separator.length)];
+}
+
+function prefixToSubstateType(prefix: string): SubstateType | null {
+  switch (prefix) {
+    case "component":
+      return "Component";
+    case "resource":
+      return "Resource";
+    case "vault":
+      return "Vault";
+    case "nft":
+      return "NonFungible";
+    case "txreceipt":
+      return "TransactionReceipt";
+    case "vnfp":
+      return "ValidatorFeePool";
+    case "template":
+      return "Template";
+    default:
+      console.log("Unknown substate type prefix", prefix);
+      return null;
+  }
+}
+
+export class SimpleSubstateDiff {
+  private up_substates: UpSubstate[];
+  private down_substates: DownSubstate[];
+  private fee_withdrawals: ValidatorFeeWithdrawal[];
+
+  constructor(diff: SubstateDiff) {
+    this.up_substates = diff.up_substates
+      .map(([id, val]: [SubstateId | string, Substate]) => {
+
+        if (!val.substate) {
+          console.error("Substate is missing in the accept result", id, val);
+          return null;
+        }
+
+        const valType = Object.keys(val.substate)[0];
+        if (!valType) {
+          console.log("Substate is missing key", id, val);
+          return null;
+        }
+        const idVal = (typeof id === "string" ? id : Object.values(id)[0]) as string;
+        return {
+          type: valType,
+          id: idVal,
+          version: val.version,
+          // @ts-ignore
+          substate: val.substate[valType],
+        } as UpSubstate;
+      })
+      .filter((x) => x !== null);
+
+    this.down_substates = diff.down_substates
+      .map(([id, version]: [SubstateId | string, number]) => {
+        const type = (typeof id === "string" ? prefixToSubstateType(splitOnce(id, "_")![0]) : Object.keys(id)[0]);
+        const idVal = substateIdToString(id);
+        return {
+          type: type! as SubstateType,
+          id: idVal,
+          version,
+        } as DownSubstate;
+      });
+
+
+    this.fee_withdrawals = diff.fee_withdrawals;
+  }
+
+  public static from(diff: SubstateDiff): SimpleSubstateDiff {
+    return new SimpleSubstateDiff(diff);
+  }
+
+  public upSubstates(): UpSubstate[] {
+    return this.up_substates;
+  }
+
+  public downSubstates(): DownSubstate[] {
+    return this.down_substates;
+  }
+
+  public feeWithdrawals(): ValidatorFeeWithdrawal[] {
+    return this.fee_withdrawals;
+  }
+}
+
+export type AnySubstate =
+  ComponentHeader
+  | Resource
+  | Vault
+  | UnclaimedConfidentialOutput
+  | NonFungible
+  | TransactionReceipt
+  | ValidatorFeePool
+  | PublishedTemplate;
+
+export type UpSubstate = {
+  type: SubstateType;
+  id: string;
+  version: number;
+  substate: AnySubstate
+};
+
+export type DownSubstate = {
+  type: SubstateType;
+  id: string;
+  version: number;
+};
+
+export class SimpleComponent {
+  private _id: string;
+  private _version: number;
+  private _substate: ComponentHeader;
+
+  constructor(id: string, version: number, substate: ComponentHeader) {
+    this._id = id;
+    this._version = version;
+    this._substate = substate;
+  }
+
+  public static new(id: string, version: number, substate: ComponentHeader): SimpleComponent {
+    return new SimpleComponent(id, version, substate);
+  }
+
+  public get id(): string {
+    return this._id;
+  }
+
+  public get version(): number {
+    return this._version;
+  }
+
+  public get substate(): ComponentHeader {
+    return this._substate;
+  }
+
+  public decodeBody<T>(): T {
+    return parseCbor(this.substate.body.state) as T;
+  }
+}
+
+
+export interface GetAccountsResult {
+  substate_id: string;
+  version: number;
+  account: BuiltInAccount;
+}

package/packages/tarijs_types/src/helpers/txResult.ts

@@ -59,11 +59,10 @@ export function getSubstateValueFromUpSubstates(
 
 export function getComponentsForTemplate(templateAddress: string, upSubstates: UpSubstates): ComponentAddress[] | null {
   const components: ComponentAddress[] = [];
-  const templateAddressBytes = new TextEncoder().encode(templateAddress);
   for (const [substateId, substate] of upSubstates) {
     if ("Component" in substate.substate) {
       const componentHeader = substate.substate.Component;
-      if (componentHeader.template_address === templateAddressBytes) {
+      if (componentHeader.template_address === templateAddress) {
         components.push(substateIdToString(substateId));
       }
     }

package/packages/tarijs_types/src/index.ts

@@ -1,5 +1,6 @@
 export { ComponentAddress, ResourceAddress, PublishedTemplateAddress, Epoch } from "@tari-project/typescript-bindings";
 export { Amount } from "./Amount";
+export { BuiltInAccount, VaultSubstate } from "./Account";
 export { TransactionArg } from "./TransactionArg";
 export { ConfidentialClaim } from "./ConfidentialClaim";
 export { ConfidentialOutput } from "./ConfidentialOutput";
@@ -53,4 +54,11 @@ export {
   txResultCheck,
   BinaryTag,
   CborValue,
+  SimpleTransactionResult,
+  SimpleSubstateDiff,
+  AnySubstate,
+  DownSubstate,
+  UpSubstate,
+  splitOnce,
 } from "./helpers";
+export { ACCOUNT_TEMPLATE_ADDRESS, XTR, TARI_RESOURCE } from "./consts";

package/packages/tarijs_types/src/signer.ts

@@ -26,7 +26,7 @@ export interface AccountData {
   account_id: number;
   address: string;
   public_key: string;
-  resources: VaultData[];
+  vaults: VaultData[];
 }
 
 export interface VaultData {

package/packages/wallet_daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/wallet-daemon-signer",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -10,7 +10,7 @@
     "build": "tsc -b"
   },
   "keywords": [],
-  "author": "",
+  "author": "The Tari Community",
   "license": "ISC",
   "dependencies": {
     "@tari-project/tari-permissions": "workspace:^",

package/packages/wallet_daemon/src/provider.ts

@@ -76,15 +76,17 @@ export class WalletDaemonTariProvider implements TariProvider {
   async getSubstate(req: GetSubstateRequest): Promise<Substate> {
     // TODO: Substate address cannot be converted to SubstateId directly - Perhaps we need to change the provider interface
     const {
-      record,
-      value,
-    } = await this.client.substatesGet({ substate_id: req.substate_address as unknown as SubstateId });
+      substate,
+    } = await this.client.substatesGet({ substate_id: req.substate_address });
+    if (!substate) {
+      throw new Error(`Substate not found for address: ${req.substate_address}`);
+    }
 
     return {
-      value,
+      value: substate?.substate,
       address: {
-        substate_id: substateIdToString(record.substate_id),
-        version: record.version,
+        substate_id: req.substate_address,
+        version: substate?.version || 0,
       },
     };
   }

package/packages/wallet_daemon/src/signer.ts

@@ -20,7 +20,6 @@ import {
   KeyBranch,
   ListAccountNftRequest,
   ListAccountNftResponse,
-  SubstateId,
   substateIdToString,
   SubstatesListRequest,
 } from "@tari-project/typescript-bindings";
@@ -44,6 +43,7 @@ export interface WalletDaemonFetchParameters extends WalletDaemonBaseParameters
   serverUrl: string;
 }
 
+
 export class WalletDaemonTariSigner implements TariSigner {
   public signerName = "WalletDaemon";
   params: WalletDaemonParameters;
@@ -93,6 +93,11 @@ export class WalletDaemonTariSigner implements TariSigner {
     return transport instanceof WebRtcRpcTransport ? transport : undefined;
   }
 
+  public async newTransactionKey(index?: number): Promise<string> {
+    const resp = await this.client.createKey({ branch: "transaction", specific_index: index || null });
+    return resp.public_key;
+  }
+
   public get token(): string | undefined {
     return this.getWebRtcTransport()?.token();
   }
@@ -125,7 +130,7 @@ export class WalletDaemonTariSigner implements TariSigner {
       account_id: res.account.key_index,
       address: (res.account.address as { Component: string }).Component,
       public_key: res.public_key,
-      resources: [],
+      vaults: [],
     };
   }
 
@@ -142,7 +147,7 @@ export class WalletDaemonTariSigner implements TariSigner {
       address,
       public_key,
       // TODO: should be vaults not resources
-      resources: balances.map((b: any) => ({
+      vaults: balances.map((b: any) => ({
         type: b.resource_type,
         resource_address: b.resource_address,
         balance: b.balance + b.confidential_balance,
@@ -158,13 +163,18 @@ export class WalletDaemonTariSigner implements TariSigner {
   }
 
   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 });
+    const {
+      substate,
+    } = await this.client.substatesGet({ substate_id: substateId });
+    if (!substate) {
+      throw new Error(`Substate not found for address: ${substateId}`);
+    }
+
     return {
-      value,
+      value: substate?.substate,
       address: {
-        substate_id: substateIdToString(record.substate_id),
-        version: record.version,
+        substate_id: substateId,
+        version: substate?.version || 0,
       },
     };
   }

package/packages/wallet_daemon/tsconfig.json

@@ -12,7 +12,7 @@
   ],
   "references": [
     {
-      "path": "../tari_permissions"
+      "path": "../permissions"
     },
     {
       "path": "../tari_provider"

package/packages/walletconnect/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/wallet-connect-signer",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -10,7 +10,7 @@
     "build": "tsc -b"
   },
   "keywords": [],
-  "author": "",
+  "author": "The Tari Community",
   "license": "ISC",
   "dependencies": {
     "@tari-project/tari-signer": "workspace:^",
@@ -18,6 +18,7 @@
     "@tari-project/tarijs-types": "workspace:^",
     "@tari-project/typescript-bindings": "catalog:",
     "@tari-project/wallet_jrpc_client": "catalog:",
+    "@tari-project/tari-permissions": "workspace:",
     "@walletconnect/modal": "catalog:",
     "@walletconnect/universal-provider": "catalog:"
   },