@tari-project/tarijs 0.2.0 → 0.3.1

package/dist/builders/helpers/submitTransaction.d.ts

@@ -4,7 +4,7 @@ import { SubmitTransactionRequest, SubstateRequirement } from "../../providers/t
 import { Transaction, TransactionResult } from "../types";
 import { DownSubstates, UpSubstates } from "../types/SubstateDiff";
 import { SubmitTxResult } from "../types/TransactionResult";
-export declare function buildTransactionRequest(transaction: Transaction, accountId: number, requiredSubstates: SubstateRequirement[], inputRefs?: never[], isDryRun?: boolean): SubmitTransactionRequest;
+export declare function buildTransactionRequest(transaction: Transaction, accountId: number, requiredSubstates: SubstateRequirement[], inputRefs?: never[], isDryRun?: boolean, network?: number, isSealSignerAuthorized?: boolean, detectInputsUseUnversioned?: boolean): SubmitTransactionRequest;
 export declare function submitAndWaitForTransaction(provider: TariProvider, req: SubmitTransactionRequest): Promise<SubmitTxResult>;
 export declare function waitForTransactionResult(provider: TariProvider | TariUniverseProvider, transactionId: string): Promise<TransactionResult>;
 export declare function getAcceptResultSubstates(txResult: TransactionResult): {

package/dist/builders/helpers/submitTransaction.js

@@ -1,8 +1,9 @@
 import { TransactionStatus } from "../types";
-export function buildTransactionRequest(transaction, accountId, requiredSubstates, inputRefs = [], isDryRun = false) {
+export function buildTransactionRequest(transaction, accountId, requiredSubstates, inputRefs = [], isDryRun = false, network = 0, isSealSignerAuthorized = true, detectInputsUseUnversioned = true) {
     return {
         //TODO refactor SubTxReq type to not use 'object[]' and types match
         // https://github.com/tari-project/tari.js/issues/25
+        network,
         account_id: accountId,
         instructions: transaction.instructions,
         fee_instructions: transaction.feeInstructions,
@@ -12,6 +13,8 @@ export function buildTransactionRequest(transaction, accountId, requiredSubstate
         is_dry_run: isDryRun,
         min_epoch: transaction.minEpoch ?? null,
         max_epoch: transaction.maxEpoch ?? null,
+        is_seal_signer_authorized: isSealSignerAuthorized,
+        detect_inputs_use_unversioned: detectInputsUseUnversioned,
     };
 }
 export async function submitAndWaitForTransaction(provider, req) {

package/dist/builders/types/Transaction.d.ts

@@ -1,8 +1,8 @@
-import { TransactionSignature } from "@tari-project/typescript-bindings";
 import { Instruction } from "./Instruction";
 import { SubstateRequirement } from "./SubstateRequirement";
 import { Epoch } from "./Epoch";
 import { VersionedSubstateId } from "./VersionedSubstateId";
+import { TransactionSignature } from "./TransactionSignature";
 export interface Transaction {
     id: string;
     feeInstructions: Array<Instruction>;

package/dist/providers/metamask/index.d.ts

@@ -1,6 +1,6 @@
 import { TariProvider } from "../index";
 import { SubmitTransactionRequest, TransactionResult, SubmitTransactionResponse, VaultBalances, TemplateDefinition, Substate, ListSubstatesResponse } from "../types";
-import { MetaMaskInpageProvider } from '@metamask/providers';
+import { MetaMaskInpageProvider } from "@metamask/providers";
 import { Snap } from "./utils";
 import { Account } from "../types";
 import { SubstateType } from "@tari-project/typescript-bindings";

package/dist/providers/metamask/index.js

@@ -1,8 +1,8 @@
 import { TransactionStatus, } from "../types";
 import { connectSnap, getSnap, isFlask } from "./utils";
-export const MetamaskNotInstalled = 'METAMASK_NOT_INSTALLED';
-export const MetamaskIsNotFlask = 'METAMASK_IS_NOT_FLASK';
-export const TariSnapNotInstalled = 'TARI_SNAP_NOT_INSTALLED';
+export const MetamaskNotInstalled = "METAMASK_NOT_INSTALLED";
+export const MetamaskIsNotFlask = "METAMASK_IS_NOT_FLASK";
+export const TariSnapNotInstalled = "TARI_SNAP_NOT_INSTALLED";
 export class MetamaskTariProvider {
     providerName = "Metamask";
     snapId;
@@ -41,32 +41,32 @@ export class MetamaskTariProvider {
         return this.metamaskConnected;
     }
     async createFreeTestCoins(account_id) {
-        const res = await this.metamaskRequest('getFreeTestCoins', {
+        const res = (await this.metamaskRequest("getFreeTestCoins", {
             amount: 1000000,
             account_id,
-            fee: 2000
-        });
+            fee: 2000,
+        }));
         return {
             account_id,
             address: res.address,
             public_key: res.public_key,
-            resources: []
+            resources: [],
         };
     }
     async getAccount() {
-        return await this.metamaskRequest('getAccountData', { account_id: 0 });
+        return (await this.metamaskRequest("getAccountData", { account_id: 0 }));
     }
     async getSubstate(substate_address) {
-        const { substate, address: substate_id, version } = await this.metamaskRequest('getSubstate', { substate_address });
+        const { substate, address: substate_id, version, } = await this.metamaskRequest("getSubstate", { substate_address });
         return { value: substate, address: { substate_id, version } };
     }
     async listSubstates(filter_by_template, filter_by_type, limit, offset) {
-        const res = await this.metamaskRequest('listSubstates', {
+        const res = (await this.metamaskRequest("listSubstates", {
             filter_by_template,
             filter_by_type,
             limit,
             offset,
-        });
+        }));
         return res;
     }
     async submitTransaction(req) {
@@ -77,7 +77,7 @@ export class MetamaskTariProvider {
             required_substates: req.required_substates || [],
             is_dry_run: req.is_dry_run,
         };
-        const resp = await this.metamaskRequest('sendTransaction', params);
+        const resp = await this.metamaskRequest("sendTransaction", params);
         if (!resp) {
             throw new Error("Failed to submit transaction to metamask snap: empty response");
         }
@@ -88,7 +88,7 @@ export class MetamaskTariProvider {
     }
     async getTransactionResult(transactionId) {
         // This request returns the response from the indexer get_transaction_result request
-        const resp = await this.metamaskRequest('getTransactionResult', { transaction_id: transactionId });
+        const resp = await this.metamaskRequest("getTransactionResult", { transaction_id: transactionId });
         if (!resp) {
             throw new Error("Failed to get transaction result from metamask snap: empty response");
         }
@@ -96,7 +96,7 @@ export class MetamaskTariProvider {
             return {
                 transaction_id: transactionId,
                 status: TransactionStatus.Pending,
-                result: null
+                result: null,
             };
         }
         if (!resp?.result?.Finalized) {
@@ -106,28 +106,27 @@ export class MetamaskTariProvider {
         return {
             transaction_id: transactionId,
             status: newStatus,
-            result: resp.result.Finalized.execution_result.finalize
+            result: resp.result.Finalized.execution_result.finalize,
         };
     }
     async getPublicKey(_branch, index) {
-        const resp = await this.metamaskRequest('getPublicKey', { index });
+        const resp = await this.metamaskRequest("getPublicKey", { index });
         if (!resp) {
             throw new Error("Failed to get public key from metamask snap: empty response");
         }
         return resp.public_key;
     }
     async getConfidentialVaultBalances(viewKeyId, vaultId, min = null, max = null) {
-        const res = await this.metamaskRequest('getConfidentialVaultBalances', {
+        const res = (await this.metamaskRequest("getConfidentialVaultBalances", {
             view_key_id: viewKeyId,
             vault_id: vaultId,
             minimum_expected_value: min,
             maximum_expected_value: max,
-        });
+        }));
         return { balances: res };
     }
     getTemplateDefinition(template_address) {
-        return this.metamaskRequest('getTemplateDefinition', { template_address })
-            .then(resp => {
+        return this.metamaskRequest("getTemplateDefinition", { template_address }).then((resp) => {
             if (!resp) {
                 throw new Error("Template not found");
             }
@@ -137,13 +136,13 @@ export class MetamaskTariProvider {
     async metamaskRequest(method, params) {
         console.log("Metamask request:", method, params);
         const resp = await this.metamask.request({
-            method: 'wallet_invokeSnap',
+            method: "wallet_invokeSnap",
             params: {
                 snapId: this.snapId,
                 request: {
                     method,
-                    params
-                }
+                    params,
+                },
             },
         });
         console.log("Metamask response:", resp);

package/dist/providers/tari_universe/provider.js

@@ -1,3 +1,4 @@
+import { sendProviderCall } from "./utils";
 export class TariUniverseProvider {
     params;
     providerName = "TariUniverse";
@@ -16,20 +17,7 @@ export class TariUniverseProvider {
     }
     async sendRequest(req) {
         const id = ++this.__id;
-        return new Promise(function (resolve, reject) {
-            const event_ref = function (resp) {
-                if (resp.data.resultError) {
-                    window.removeEventListener("message", event_ref);
-                    reject(resp.data.resultError);
-                }
-                if (resp && resp.data && resp.data.id && resp.data.id == id && resp.data.type === "provider-call") {
-                    window.removeEventListener("message", event_ref);
-                    resolve(resp.data.result);
-                }
-            };
-            window.addEventListener("message", event_ref, false);
-            window.parent.postMessage({ ...req, id, type: "provider-call" }, "*");
-        });
+        return sendProviderCall(req, id);
     }
     isConnected() {
         return true;
@@ -56,7 +44,20 @@ export class TariUniverseProvider {
         return this.sendRequest({ methodName: "requestParentSize", args: [] });
     }
     async getAccount() {
-        return this.sendRequest({ methodName: "getAccount", args: [] });
+        const { account_id, address, public_key } = await this.sendRequest({ methodName: "getAccount", args: [] });
+        const { balances } = await this.getAccountBalances(address);
+        return {
+            account_id,
+            address,
+            public_key,
+            resources: balances.map((b) => ({
+                type: b.resource_type,
+                resource_address: b.resource_address,
+                balance: b.balance + b.confidential_balance,
+                vault_id: "Vault" in b.vault_address ? b.vault_address.Vault : b.vault_address,
+                token_symbol: b.token_symbol,
+            })),
+        };
     }
     async getAccountBalances(componentAddress) {
         return this.sendRequest({

package/dist/providers/tari_universe/utils.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMethodNames, ProviderRequest, ProviderReturnType } from "./types";
+export declare function sendProviderCall<MethodName extends ProviderMethodNames>(req: Omit<ProviderRequest<MethodName>, "id">, id: number): Promise<ProviderReturnType<MethodName>>;

package/dist/providers/tari_universe/utils.js

@@ -0,0 +1,16 @@
+export function sendProviderCall(req, id) {
+    return new Promise((resolve, reject) => {
+        const event_ref = (resp) => {
+            if (resp.data.resultError) {
+                window.removeEventListener("message", event_ref);
+                reject(resp.data.resultError);
+            }
+            if (resp && resp.data && resp.data.id && resp.data.id === id && resp.data.type === "provider-call") {
+                window.removeEventListener("message", event_ref);
+                resolve(resp.data.result);
+            }
+        };
+        window.addEventListener("message", event_ref, false);
+        window.parent.postMessage({ ...req, id, type: "provider-call" }, "*");
+    });
+}

package/dist/providers/types.d.ts

@@ -10,6 +10,7 @@ export type SubstateRequirement = {
     version?: number | null;
 };
 export type SubmitTransactionRequest = {
+    network: number;
     account_id: number;
     instructions: object[];
     fee_instructions: object[];
@@ -19,6 +20,8 @@ export type SubmitTransactionRequest = {
     is_dry_run: boolean;
     min_epoch: number | null;
     max_epoch: number | null;
+    is_seal_signer_authorized: boolean;
+    detect_inputs_use_unversioned: boolean;
 };
 export type SubmitTransactionResponse = {
     transaction_id: string;

package/dist/providers/wallet_daemon/provider.d.ts

@@ -5,27 +5,35 @@ import { Account } from "../types";
 import { WalletDaemonClient, SubstateType } from "@tari-project/wallet_jrpc_client";
 export declare const WalletDaemonNotConnected = "WALLET_DAEMON_NOT_CONNECTED";
 export declare const Unsupported = "UNSUPPORTED";
-export type WalletDaemonParameters = {
-    signalingServerUrl?: string;
+export interface WalletDaemonBaseParameters {
     permissions: TariPermissions;
-    optionalPermissions: TariPermissions;
+    optionalPermissions?: TariPermissions;
+    onConnection?: () => void;
+}
+export interface WalletDaemonParameters extends WalletDaemonBaseParameters {
+    signalingServerUrl?: string;
     webRtcConfig?: RTCConfiguration;
     name?: string;
-    onConnection?: () => void;
-};
+}
+export interface WalletDaemonFetchParameters extends WalletDaemonBaseParameters {
+    serverUrl: string;
+}
 export declare class WalletDaemonTariProvider implements TariProvider {
     providerName: string;
     params: WalletDaemonParameters;
     client: WalletDaemonClient;
     private constructor();
     static build(params: WalletDaemonParameters): Promise<WalletDaemonTariProvider>;
+    static buildFetchProvider(params: WalletDaemonFetchParameters): Promise<WalletDaemonTariProvider>;
+    private static buildPermissions;
+    private getWebRtcTransport;
     get token(): string | undefined;
     get tokenUrl(): string | undefined;
     isConnected(): boolean;
     createFreeTestCoins(): Promise<Account>;
     getAccount(): Promise<Account>;
     getAccountBalances(componentAddress: string): Promise<unknown>;
-    getSubstate(substate_id: string): Promise<Substate>;
+    getSubstate(substateId: string): Promise<Substate>;
     submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
     getTransactionResult(transactionId: string): Promise<TransactionResult>;
     getPublicKey(branch: string, index: number): Promise<string>;

package/dist/providers/wallet_daemon/provider.js

@@ -1,10 +1,11 @@
 import { TariPermissions, } from "./tari_permissions";
 import { TariConnection } from "./webrtc";
 import { TransactionStatus, } from "../types";
-import { WalletDaemonClient, stringToSubstateId, substateIdToString, } from "@tari-project/wallet_jrpc_client";
+import { WalletDaemonClient, substateIdToString, } from "@tari-project/wallet_jrpc_client";
 import { WebRtcRpcTransport } from "./webrtc_transport";
 export const WalletDaemonNotConnected = 'WALLET_DAEMON_NOT_CONNECTED';
 export const Unsupported = 'UNSUPPORTED';
+;
 export class WalletDaemonTariProvider {
     providerName = "WalletDaemon";
     params;
@@ -14,10 +15,7 @@ export class WalletDaemonTariProvider {
         this.client = connection;
     }
     static async build(params) {
-        const allPermissions = new TariPermissions();
-        allPermissions.addPermissions(params.permissions);
-        allPermissions.addPermissions(params.optionalPermissions);
-        console.log({ allPermissions });
+        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) => {
@@ -28,8 +26,29 @@ export class WalletDaemonTariProvider {
         });
         return new WalletDaemonTariProvider(params, client);
     }
+    static async buildFetchProvider(params) {
+        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);
+    }
+    static buildPermissions(params) {
+        const allPermissions = new TariPermissions();
+        allPermissions.addPermissions(params.permissions);
+        if (params.optionalPermissions) {
+            allPermissions.addPermissions(params.optionalPermissions);
+        }
+        return allPermissions;
+    }
+    getWebRtcTransport() {
+        const transport = this.client.getTransport();
+        return transport instanceof WebRtcRpcTransport ? transport : undefined;
+    }
     get token() {
-        return this.client.getTransport().token();
+        return this.getWebRtcTransport()?.token();
     }
     get tokenUrl() {
         if (!this.token) {
@@ -42,7 +61,7 @@ export class WalletDaemonTariProvider {
         return `tari://${name}/${token}/${permissions}/${optionalPermissions}`;
     }
     isConnected() {
-        return this.client.getTransport().isConnected();
+        return this.getWebRtcTransport()?.isConnected() || true;
     }
     async createFreeTestCoins() {
         const res = await this.client.createFreeTestCoins({
@@ -60,17 +79,18 @@ export class WalletDaemonTariProvider {
     }
     async getAccount() {
         const { account, public_key } = await this.client.accountsGetDefault({});
-        const { balances } = await this.client.accountsGetBalances({ account: { ComponentAddress: account.address.Component }, refresh: false });
+        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: account.address.Component,
+            address,
             public_key,
             // TODO: should be vaults not resources
             resources: balances.map((b) => ({
                 type: b.resource_type,
                 resource_address: b.resource_address,
                 balance: b.balance + b.confidential_balance,
-                vault_id: ('Vault' in b.vault_address) ? b.vault_address.Vault : b.vault_address,
+                vault_id: (typeof (b.vault_address) === "object" && 'Vault' in b.vault_address) ? b.vault_address.Vault : b.vault_address,
                 token_symbol: b.token_symbol,
             }))
         };
@@ -78,8 +98,8 @@ export class WalletDaemonTariProvider {
     async getAccountBalances(componentAddress) {
         return await this.client.accountsGetBalances({ account: { ComponentAddress: componentAddress }, refresh: true });
     }
-    async getSubstate(substate_id) {
-        const substateId = stringToSubstateId(substate_id);
+    async getSubstate(substateId) {
+        // Wallet daemon expects a SubstateId as a string
         const { value, record } = await this.client.substatesGet({ substate_id: substateId });
         return {
             value,
@@ -92,20 +112,25 @@ export class WalletDaemonTariProvider {
     async submitTransaction(req) {
         const params = {
             transaction: {
-                instructions: req.instructions,
-                fee_instructions: req.fee_instructions,
-                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,
-                    version: s.version
-                })),
-                min_epoch: null,
-                max_epoch: null,
+                V1: {
+                    network: req.network,
+                    instructions: req.instructions,
+                    fee_instructions: req.fee_instructions,
+                    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,
+                        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 };
@@ -143,10 +168,10 @@ export class WalletDaemonTariProvider {
             offset
         });
         const substates = resp.substates.map((s) => ({
-            substate_id: substateIdToString(s.substate_id),
+            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
+            template_address: s.template_address,
         }));
         return { substates };
     }

package/dist/providers/walletconnect/index.js

@@ -1,7 +1,7 @@
 import { TransactionStatus, } from "../types";
 import UniversalProvider from '@walletconnect/universal-provider';
 import { WalletConnectModal } from '@walletconnect/modal';
-import { stringToSubstateId, substateIdToString } from "@tari-project/wallet_jrpc_client";
+import { substateIdToString } from "@tari-project/wallet_jrpc_client";
 const walletConnectParams = {
     requiredNamespaces: {
         tari: {
@@ -83,31 +83,30 @@ export class WalletConnectTariProvider {
     }
     async getAccount() {
         const { account, public_key } = await this.sendRequest('tari_getDefaultAccount', {});
-        const { balances } = await this.sendRequest('tari_getAccountBalances', { account: { ComponentAddress: account.address.Component }, refresh: false
+        const { balances } = await this.sendRequest('tari_getAccountBalances', { account: { ComponentAddress: account.address }, refresh: false
         });
         return {
             account_id: account.key_index,
-            address: account.address.Component,
+            address: account.address,
             public_key,
             // TODO: should be vaults not resources
             resources: balances.map((b) => ({
                 type: b.resource_type,
                 resource_address: b.resource_address,
                 balance: b.balance + b.confidential_balance,
-                vault_id: ('Vault' in b.vault_address) ? b.vault_address.Vault : b.vault_address,
+                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) {
-        const substateId = stringToSubstateId(substate_address);
         const method = 'tari_getSubstate';
-        const params = { substate_id: substateId };
+        const params = { substate_id: substate_address };
         const { value, record } = await this.sendRequest(method, params);
         return {
             value,
             address: {
-                substate_id: substateIdToString(record.substate_id),
+                substate_id: record.substate_id,
                 version: record.version
             }
         };
@@ -149,20 +148,25 @@ export class WalletConnectTariProvider {
         const method = 'tari_submitTransaction';
         const params = {
             transaction: {
-                fee_instructions: req.fee_instructions,
-                instructions: req.instructions,
-                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,
-                    version: s.version
-                })),
-                min_epoch: null,
-                max_epoch: null,
+                V1: {
+                    network: req.network,
+                    fee_instructions: req.fee_instructions,
+                    instructions: req.instructions,
+                    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,
+                        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 };

package/package.json

@@ -1,27 +1,29 @@
 {
   "name": "@tari-project/tarijs",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "integration-tests": "vitest run integration-tests"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@metamask/providers": "^9.0.0",
-    "@tari-project/wallet_jrpc_client": "^1.1.0",
-    "@tari-project/typescript-bindings": "^1.1.0",
+    "@metamask/providers": "^18.2.0",
+    "@tari-project/typescript-bindings": "^1.4.0",
+    "@tari-project/wallet_jrpc_client": "^1.4.0",
     "@walletconnect/modal": "^2.6.2",
     "@walletconnect/universal-provider": "^2.13.3"
   },
   "devDependencies": {
     "@types/node": "^20.12.6",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "vitest": "^3.0.4"
   },
   "files": [
     "/dist"