@tari-project/tarijs 0.3.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/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.3.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": "^18.2.0",
-    "@tari-project/wallet_jrpc_client": "^1.1.0",
-    "@tari-project/typescript-bindings": "^1.1.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"