@tari-project/tarijs-types 0.11.0 → 0.12.0

package/dist/Account.d.ts

@@ -0,0 +1,15 @@
+import { BigAmount, ResourceAddress, ResourceType, Vault, VaultId } from "@tari-project/typescript-bindings";
+export interface BuiltInAccount {
+    vaults: Record<ResourceAddress, VaultSubstate>;
+}
+export declare class VaultSubstate {
+    private vaultId;
+    private vault;
+    constructor(vaultId: VaultId, vault: Vault);
+    static new(vaultId: VaultId, vault: Vault): VaultSubstate;
+    get id(): VaultId;
+    get rawVault(): Vault;
+    get resourceType(): ResourceType;
+    get balance(): BigAmount;
+    get resourceAddress(): ResourceAddress;
+}

package/dist/Account.js

@@ -0,0 +1,54 @@
+import { BigAmount } from "@tari-project/typescript-bindings";
+export class VaultSubstate {
+    vaultId;
+    vault;
+    constructor(vaultId, vault) {
+        this.vaultId = vaultId;
+        this.vault = vault;
+    }
+    static new(vaultId, vault) {
+        return new VaultSubstate(vaultId, vault);
+    }
+    get id() {
+        return this.vaultId;
+    }
+    get rawVault() {
+        return this.vault;
+    }
+    get 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");
+    }
+    get balance() {
+        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");
+    }
+    get 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");
+    }
+}

package/dist/Amount.d.ts

@@ -2,7 +2,7 @@ export declare class Amount {
     private value;
     constructor(value: number);
     static readonly MAX: Amount;
-    static newAmount(amount: number): Amount;
+    static new(amount: number): Amount;
     static zero(): Amount;
     isZero(): boolean;
     isPositive(): boolean;
@@ -20,4 +20,5 @@ export declare class Amount {
     checkedDiv(other: Amount): Amount | null;
     saturatingDiv(other: Amount): Amount;
     asU64Checked(): number | null;
+    toJSON(): number;
 }

package/dist/Amount.js

@@ -4,7 +4,7 @@ export class Amount {
         this.value = value;
     }
     static MAX = new Amount(Number.MAX_SAFE_INTEGER);
-    static newAmount(amount) {
+    static new(amount) {
         return new Amount(amount);
     }
     static zero() {
@@ -90,4 +90,7 @@ export class Amount {
         }
         return this.value;
     }
+    toJSON() {
+        return this.value;
+    }
 }

package/dist/TransactionResult.d.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;
 };
@@ -12,8 +11,3 @@ export interface SubmitTxResult {
     newComponents: UpSubstates;
     getComponentForTemplate(templateAddress: string): ComponentAddress | null;
 }
-export type TransactionResultResponse = {
-    transaction_id: string;
-    status: TransactionStatus;
-    result: FinalizeResult | null;
-};

package/dist/consts.d.ts

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

package/dist/consts.js

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

package/dist/helpers/index.d.ts

@@ -3,6 +3,7 @@ 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, shortenSubstateId, shortenString, rejectReasonToString, getSubstateDiffFromTransactionResult, getRejectReasonFromTransactionResult, jrpcPermissionToString, } from "@tari-project/typescript-bindings";
 export declare function convertStringToTransactionStatus(status: string): TransactionStatus;
 export declare function createNftAddressFromToken(token: NonFungibleToken): string;

package/dist/helpers/index.js

@@ -2,6 +2,7 @@ import { TransactionStatus } from "../TransactionStatus";
 export { fromHexString, toHexString } from "./hexString";
 export { txResultCheck, getSubstateValueFromUpSubstates, getComponentsForTemplate } from "./txResult";
 export { BinaryTag, convertTaggedValue, getCborValueByPath, parseCbor } from "./cbor";
+export { SimpleSubstateDiff, SimpleTransactionResult, splitOnce, } from "./simpleResult";
 export { substateIdToString, stringToSubstateId, shortenSubstateId, shortenString, rejectReasonToString, getSubstateDiffFromTransactionResult, getRejectReasonFromTransactionResult, jrpcPermissionToString, } from "@tari-project/typescript-bindings";
 export function convertStringToTransactionStatus(status) {
     switch (status) {

package/dist/helpers/simpleResult.d.ts

@@ -0,0 +1,76 @@
+import { Vault, ComponentHeader, NonFungible, RejectReason, Resource, 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 } from "@thames/monads";
+import { GetTransactionResultResponse } from "../GetTransactionResultResponse";
+export declare class SimpleTransactionResult {
+    private readonly transaction_id;
+    private readonly finalizeResult;
+    private readonly _status;
+    constructor(transaction_id: TransactionId, status: TransactionStatus, result: FinalizeResult);
+    static new(transaction_id: TransactionId, status: TransactionStatus, result: FinalizeResult): SimpleTransactionResult;
+    static fromResponse(resp: GetTransactionResultResponse): SimpleTransactionResult;
+    get transactionId(): string;
+    get result(): FinalizeResult;
+    get status(): TransactionStatus;
+    get logs(): LogEntry[];
+    get events(): Event[];
+    getResultingComponents(): ComponentHeader[];
+    getResultingResources(): Resource[];
+    getResultingVaults(): VaultSubstate[];
+    getResultingNonFungibles(): NonFungible[];
+    getTransactionReceipt(): TransactionReceipt;
+    getNewPublishedTemplates(): PublishedTemplate[];
+    getNewSubstatesOfType(type: SubstateType): AnySubstate[];
+    getUpSubstatesOfType(type: SubstateType): UpSubstate[];
+    getComponentsByTemplateAddress(templateAddress: PublishedTemplateAddress): SimpleComponent[];
+    getResultingAccounts(): GetAccountsResult[];
+    /**
+     * 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.
+     */
+    get anyRejectReason(): Option<RejectReason>;
+    get accept(): Option<SimpleSubstateDiff>;
+    get diff(): Option<SimpleSubstateDiff>;
+    get onlyFeeAccepted(): Option<[SimpleSubstateDiff, RejectReason]>;
+    get rejected(): Option<RejectReason>;
+}
+export declare function splitOnce(str: string, separator: string): [string, string] | null;
+export declare class SimpleSubstateDiff {
+    private up_substates;
+    private down_substates;
+    private fee_withdrawals;
+    constructor(diff: SubstateDiff);
+    static from(diff: SubstateDiff): SimpleSubstateDiff;
+    upSubstates(): UpSubstate[];
+    downSubstates(): DownSubstate[];
+    feeWithdrawals(): ValidatorFeeWithdrawal[];
+}
+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 declare class SimpleComponent {
+    private _id;
+    private _version;
+    private _substate;
+    constructor(id: string, version: number, substate: ComponentHeader);
+    static new(id: string, version: number, substate: ComponentHeader): SimpleComponent;
+    get id(): string;
+    get version(): number;
+    get substate(): ComponentHeader;
+    decodeBody<T>(): T;
+}
+export interface GetAccountsResult {
+    substate_id: string;
+    version: number;
+    account: BuiltInAccount;
+}

package/dist/helpers/simpleResult.js

@@ -0,0 +1,239 @@
+import { substateIdToString, } from "@tari-project/typescript-bindings";
+import { VaultSubstate } from "../Account";
+import { Some, None } from "@thames/monads";
+import { parseCbor } from "../";
+import { ACCOUNT_TEMPLATE_ADDRESS } from "../consts";
+export class SimpleTransactionResult {
+    transaction_id;
+    finalizeResult;
+    _status;
+    constructor(transaction_id, status, result) {
+        this.transaction_id = transaction_id;
+        this._status = status;
+        this.finalizeResult = result;
+    }
+    static new(transaction_id, status, result) {
+        return new SimpleTransactionResult(transaction_id, status, result);
+    }
+    static fromResponse(resp) {
+        if (!resp.result) {
+            throw new Error("Transaction result is missing in the response");
+        }
+        return SimpleTransactionResult.new(resp.transaction_id, resp.status, resp.result);
+    }
+    get transactionId() {
+        return this.transaction_id;
+    }
+    get result() {
+        return this.finalizeResult;
+    }
+    get status() {
+        return this._status;
+    }
+    get logs() {
+        return this.result.logs;
+    }
+    get events() {
+        return this.result.events;
+    }
+    getResultingComponents() {
+        return this.getNewSubstatesOfType("Component");
+    }
+    getResultingResources() {
+        return this.getNewSubstatesOfType("Resource");
+    }
+    getResultingVaults() {
+        const vaults = this.getUpSubstatesOfType("Vault");
+        return vaults.map((upSubstate) => VaultSubstate.new(upSubstate.id, upSubstate.substate));
+    }
+    getResultingNonFungibles() {
+        return this.getNewSubstatesOfType("NonFungible");
+    }
+    getTransactionReceipt() {
+        return this.getNewSubstatesOfType("TransactionReceipt")[0];
+    }
+    getNewPublishedTemplates() {
+        return this.getNewSubstatesOfType("Template");
+    }
+    getNewSubstatesOfType(type) {
+        const upSubstates = this.getUpSubstatesOfType(type);
+        return upSubstates.map((upSubstate) => upSubstate.substate);
+    }
+    getUpSubstatesOfType(type) {
+        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;
+    }
+    getComponentsByTemplateAddress(templateAddress) {
+        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.template_address === templateAddress) {
+                components.push(SimpleComponent.new(upSubstate.id, upSubstate.version, upSubstate.substate));
+            }
+        }
+        return components;
+    }
+    getResultingAccounts() {
+        const components = this.getComponentsByTemplateAddress(ACCOUNT_TEMPLATE_ADDRESS);
+        const accounts = [];
+        for (const component of components) {
+            const account = component.decodeBody();
+            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.
+     */
+    get anyRejectReason() {
+        return this.rejected.or(this.onlyFeeAccepted.map((x) => x[1]));
+    }
+    get accept() {
+        const result = this.result;
+        const accept = result?.result.Accept;
+        if (!accept) {
+            return None;
+        }
+        return Some(SimpleSubstateDiff.from(accept));
+    }
+    get diff() {
+        return this.accept.or(this.onlyFeeAccepted.map((x => x[0])));
+    }
+    get onlyFeeAccepted() {
+        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]);
+    }
+    get rejected() {
+        const result = this.result;
+        if (!result || !result.result) {
+            return None;
+        }
+        if (!("Reject" in result.result)) {
+            return None;
+        }
+        return Some(result?.result.Reject);
+    }
+}
+export function splitOnce(str, separator) {
+    const index = str.indexOf(separator);
+    if (index === -1) {
+        return null;
+    }
+    return [str.slice(0, index), str.slice(index + separator.length)];
+}
+function prefixToSubstateType(prefix) {
+    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 {
+    up_substates;
+    down_substates;
+    fee_withdrawals;
+    constructor(diff) {
+        this.up_substates = diff.up_substates
+            .map(([id, val]) => {
+            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]);
+            return {
+                type: valType,
+                id: idVal,
+                version: val.version,
+                // @ts-ignore
+                substate: val.substate[valType],
+            };
+        })
+            .filter((x) => x !== null);
+        this.down_substates = diff.down_substates
+            .map(([id, version]) => {
+            const type = (typeof id === "string" ? prefixToSubstateType(splitOnce(id, "_")[0]) : Object.keys(id)[0]);
+            const idVal = substateIdToString(id);
+            return {
+                type: type,
+                id: idVal,
+                version,
+            };
+        });
+        this.fee_withdrawals = diff.fee_withdrawals;
+    }
+    static from(diff) {
+        return new SimpleSubstateDiff(diff);
+    }
+    upSubstates() {
+        return this.up_substates;
+    }
+    downSubstates() {
+        return this.down_substates;
+    }
+    feeWithdrawals() {
+        return this.fee_withdrawals;
+    }
+}
+export class SimpleComponent {
+    _id;
+    _version;
+    _substate;
+    constructor(id, version, substate) {
+        this._id = id;
+        this._version = version;
+        this._substate = substate;
+    }
+    static new(id, version, substate) {
+        return new SimpleComponent(id, version, substate);
+    }
+    get id() {
+        return this._id;
+    }
+    get version() {
+        return this._version;
+    }
+    get substate() {
+        return this._substate;
+    }
+    decodeBody() {
+        return parseCbor(this.substate.body.state);
+    }
+}

package/dist/helpers/txResult.js

@@ -33,11 +33,10 @@ export function getSubstateValueFromUpSubstates(substateType, upSubstates) {
 }
 export function getComponentsForTemplate(templateAddress, upSubstates) {
     const components = [];
-    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/dist/index.d.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";
@@ -14,4 +15,5 @@ export { WorkspaceArg } from "./Workspace";
 export { ListAccountNftFromBalancesRequest } from "./ListAccountNftFromBalancesRequest";
 export { Network } from "./network";
 export { AccountData, ListSubstatesRequest, ListSubstatesResponse, SubmitTransactionRequest, Substate, SubstateMetadata, ReqSubstate, TemplateDefinition, VaultBalances, VaultData, GetSubstateRequest, } from "./signer";
-export { convertHexStringToU256Array, convertStringToTransactionStatus, convertU256ToHexString, createNftAddressFromResource, createNftAddressFromToken, getRejectReasonFromTransactionResult, getSubstateDiffFromTransactionResult, jrpcPermissionToString, rejectReasonToString, shortenString, shortenSubstateId, stringToSubstateId, substateIdToString, fromHexString, toHexString, convertTaggedValue, getCborValueByPath, parseCbor, getSubstateValueFromUpSubstates, getComponentsForTemplate, txResultCheck, BinaryTag, CborValue, } from "./helpers";
+export { convertHexStringToU256Array, convertStringToTransactionStatus, convertU256ToHexString, createNftAddressFromResource, createNftAddressFromToken, getRejectReasonFromTransactionResult, getSubstateDiffFromTransactionResult, jrpcPermissionToString, rejectReasonToString, shortenString, shortenSubstateId, stringToSubstateId, substateIdToString, fromHexString, toHexString, convertTaggedValue, getCborValueByPath, parseCbor, getSubstateValueFromUpSubstates, getComponentsForTemplate, txResultCheck, BinaryTag, CborValue, SimpleTransactionResult, SimpleSubstateDiff, AnySubstate, DownSubstate, UpSubstate, splitOnce, } from "./helpers";
+export { ACCOUNT_TEMPLATE_ADDRESS, XTR, TARI_RESOURCE } from "./consts";

package/dist/index.js

@@ -1,4 +1,6 @@
 export { Amount } from "./Amount";
+export { VaultSubstate } from "./Account";
 export { TransactionStatus, transactionStatusFromStr } from "./TransactionStatus";
 export { Network } from "./network";
-export { convertHexStringToU256Array, convertStringToTransactionStatus, convertU256ToHexString, createNftAddressFromResource, createNftAddressFromToken, getRejectReasonFromTransactionResult, getSubstateDiffFromTransactionResult, jrpcPermissionToString, rejectReasonToString, shortenString, shortenSubstateId, stringToSubstateId, substateIdToString, fromHexString, toHexString, convertTaggedValue, getCborValueByPath, parseCbor, getSubstateValueFromUpSubstates, getComponentsForTemplate, txResultCheck, BinaryTag, } from "./helpers";
+export { convertHexStringToU256Array, convertStringToTransactionStatus, convertU256ToHexString, createNftAddressFromResource, createNftAddressFromToken, getRejectReasonFromTransactionResult, getSubstateDiffFromTransactionResult, jrpcPermissionToString, rejectReasonToString, shortenString, shortenSubstateId, stringToSubstateId, substateIdToString, fromHexString, toHexString, convertTaggedValue, getCborValueByPath, parseCbor, getSubstateValueFromUpSubstates, getComponentsForTemplate, txResultCheck, BinaryTag, SimpleTransactionResult, SimpleSubstateDiff, splitOnce, } from "./helpers";
+export { ACCOUNT_TEMPLATE_ADDRESS, XTR, TARI_RESOURCE } from "./consts";

package/dist/signer.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tari-project/tarijs-types",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -10,7 +10,8 @@
   "author": "The Tari Community",
   "license": "ISC",
   "dependencies": {
-    "@tari-project/typescript-bindings": ">=1.13.0"
+    "@tari-project/typescript-bindings": ">=1.14.0",
+    "@thames/monads": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.1",