@tari-project/tarijs 0.1.21 → 0.1.22

package/dist/providers/metamask/utils.js

@@ -0,0 +1,55 @@
+/**
+ * Get the installed snaps in MetaMask.
+ *
+ * @param provider - The MetaMask inpage provider.
+ * @returns The snaps installed in MetaMask.
+ */
+export const getSnaps = async (provider) => (await provider.request({
+    method: 'wallet_getSnaps',
+}));
+/**
+ * Connect a snap to MetaMask.
+ *
+ * @param snapId - The ID of the snap.
+ * @param params - The params to pass with the snap to connect.
+ */
+export const connectSnap = async (provider, snaps) => {
+    await provider.request({
+        method: 'wallet_requestSnaps',
+        params: snaps,
+    });
+};
+/**
+ * Get the snap from MetaMask.
+ *
+ * @param version - The version of the snap to install (optional).
+ * @returns The snap object returned by the extension.
+ */
+export const getSnap = async (provider, snapId, version) => {
+    try {
+        const snaps = await getSnaps(provider);
+        return Object.values(snaps).find((snap) => snap.id === snapId && (!version || snap.version === version));
+    }
+    catch (e) {
+        console.log('Failed to obtain installed snap', e);
+        return undefined;
+    }
+};
+export const isLocalSnap = (snapId) => snapId.startsWith('local:');
+/**
+ * Detect if the wallet injecting the ethereum object is MetaMask Flask.
+ *
+ * @returns True if the MetaMask version is Flask, false otherwise.
+ */
+export const isFlask = async (provider) => {
+    try {
+        const clientVersion = await provider.request({
+            method: 'web3_clientVersion',
+        });
+        const isFlaskDetected = clientVersion?.includes('flask');
+        return Boolean(provider && isFlaskDetected);
+    }
+    catch {
+        return false;
+    }
+};

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

@@ -0,0 +1,3 @@
+export * from "../wallet_daemon/tari_permissions";
+export * from "./provider";
+export * from "./types";

package/dist/providers/tari_universe/index.js

@@ -0,0 +1,3 @@
+export * from "../wallet_daemon/tari_permissions";
+export * from "./provider";
+export * from "./types";

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

@@ -0,0 +1,23 @@
+import { SubmitTransactionRequest, TransactionResult, SubmitTransactionResponse, Account, Substate, TemplateDefinition, VaultBalances, ListSubstatesResponse } from "../types";
+import { TariUniverseProviderParameters, WindowSize } from "./types";
+import { TariProvider } from "../index";
+import { AccountsGetBalancesResponse, SubstateType } from "@tari-project/wallet_jrpc_client";
+export declare class TariUniverseProvider implements TariProvider {
+    params: TariUniverseProviderParameters;
+    providerName: string;
+    private __id;
+    constructor(params: TariUniverseProviderParameters);
+    private sendRequest;
+    isConnected(): boolean;
+    getPublicKey(): Promise<string>;
+    listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse>;
+    getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min: number | null, max: number | null): Promise<VaultBalances>;
+    createFreeTestCoins(): Promise<void>;
+    requestParentSize(): Promise<WindowSize>;
+    getAccount(): Promise<Account>;
+    getAccountBalances(componentAddress: string): Promise<AccountsGetBalancesResponse>;
+    getSubstate(substate_id: string): Promise<Substate>;
+    submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
+    getTransactionResult(transactionId: string): Promise<TransactionResult>;
+    getTemplateDefinition(template_address: string): Promise<TemplateDefinition>;
+}

package/dist/providers/tari_universe/provider.js

@@ -0,0 +1,88 @@
+export class TariUniverseProvider {
+    params;
+    providerName = "TariUniverse";
+    __id = 0;
+    constructor(params) {
+        this.params = params;
+        const filterResizeEvent = function (event) {
+            if (event.data && event.data.type === "resize") {
+                const resizeEvent = new CustomEvent("resize", {
+                    detail: { width: event.data.width, height: event.data.height },
+                });
+                window.dispatchEvent(resizeEvent);
+            }
+        };
+        window.addEventListener("message", (event) => filterResizeEvent(event), false);
+    }
+    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" }, "*");
+        });
+    }
+    isConnected() {
+        return true;
+    }
+    getPublicKey() {
+        return this.sendRequest({ methodName: "getPublicKey", args: [] });
+    }
+    async listSubstates(filter_by_template, filter_by_type, limit, offset) {
+        return this.sendRequest({
+            methodName: "listSubstates",
+            args: [filter_by_template, filter_by_type, limit, offset],
+        });
+    }
+    getConfidentialVaultBalances(viewKeyId, vaultId, min, max) {
+        return this.sendRequest({
+            methodName: "getConfidentialVaultBalances",
+            args: [viewKeyId, vaultId, min, max],
+        });
+    }
+    async createFreeTestCoins() {
+        return this.sendRequest({ methodName: "createFreeTestCoins", args: [] });
+    }
+    requestParentSize() {
+        return this.sendRequest({ methodName: "requestParentSize", args: [] });
+    }
+    async getAccount() {
+        return this.sendRequest({ methodName: "getAccount", args: [] });
+    }
+    async getAccountBalances(componentAddress) {
+        return this.sendRequest({
+            methodName: "getAccountBalances",
+            args: [componentAddress],
+        });
+    }
+    async getSubstate(substate_id) {
+        return this.sendRequest({
+            methodName: "getSubstate",
+            args: [substate_id],
+        });
+    }
+    async submitTransaction(req) {
+        return this.sendRequest({
+            methodName: "submitTransaction",
+            args: [req],
+        });
+    }
+    async getTransactionResult(transactionId) {
+        return this.sendRequest({
+            methodName: "getTransactionResult",
+            args: [transactionId],
+        });
+    }
+    async getTemplateDefinition(template_address) {
+        return this.sendRequest({ methodName: "getTemplateDefinition", args: [template_address] });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { TariPermissions } from "../wallet_daemon";
+import { TariUniverseProvider } from "./provider";
+export type TariUniverseProviderParameters = {
+    permissions: TariPermissions;
+    optionalPermissions: TariPermissions;
+    name?: string;
+    onConnection?: () => void;
+};
+export type WindowSize = {
+    width: number;
+    height: number;
+};
+export type PickMatching<T, V> = {
+    [K in keyof T as T[K] extends V ? K : never]: T[K];
+};
+export type ExtractMethods<T> = PickMatching<T, Function>;
+export type ProviderMethods = ExtractMethods<TariUniverseProvider>;
+export type ProviderMethodNames = keyof ProviderMethods;
+export type ProviderReturnType<T extends ProviderMethodNames> = Awaited<ReturnType<ProviderMethods[T]>>;
+export type ProviderRequest<T extends ProviderMethodNames> = {
+    id: number;
+    methodName: T;
+    args: Parameters<ProviderMethods[T]>;
+};
+export type ProviderResponse<T extends ProviderMethodNames> = {
+    id: number;
+    type: "provider-call";
+    result: ProviderReturnType<T>;
+    resultError?: string;
+};

package/dist/providers/tari_universe/types.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/types.d.ts

@@ -0,0 +1,66 @@
+import { FinalizeResult } from "@tari-project/typescript-bindings";
+export type SubstateMetadata = {
+    substate_id: string;
+    module_name: string | null;
+    version: number;
+    template_address: string | null;
+};
+export type SubstateRequirement = {
+    substate_id: string;
+    version?: number | null;
+};
+export type SubmitTransactionRequest = {
+    account_id: number;
+    instructions: object[];
+    fee_instructions: object[];
+    inputs: object[];
+    input_refs: object[];
+    required_substates: SubstateRequirement[];
+    is_dry_run: boolean;
+    min_epoch: number | null;
+    max_epoch: number | null;
+};
+export type SubmitTransactionResponse = {
+    transaction_id: string;
+};
+export type TransactionResult = {
+    transaction_id: string;
+    status: TransactionStatus;
+    result: FinalizeResult | null;
+};
+export declare enum TransactionStatus {
+    New = 0,
+    DryRun = 1,
+    Pending = 2,
+    Accepted = 3,
+    Rejected = 4,
+    InvalidTransaction = 5,
+    OnlyFeeAccepted = 6
+}
+export interface Account {
+    account_id: number;
+    address: string;
+    public_key: string;
+    resources: VaultData[];
+}
+export interface VaultData {
+    type: string;
+    balance: number;
+    resource_address: string;
+}
+export interface VaultBalances {
+    balances: Map<string, number | null>;
+}
+export interface TemplateDefinition {
+    [key: string]: any;
+}
+export interface Substate {
+    value: any;
+    address: {
+        substate_id: string;
+        version: number;
+    };
+}
+export type ListSubstatesResponse = {
+    substates: Array<SubstateMetadata>;
+};

package/dist/providers/types.js

@@ -0,0 +1,10 @@
+export var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus[TransactionStatus["New"] = 0] = "New";
+    TransactionStatus[TransactionStatus["DryRun"] = 1] = "DryRun";
+    TransactionStatus[TransactionStatus["Pending"] = 2] = "Pending";
+    TransactionStatus[TransactionStatus["Accepted"] = 3] = "Accepted";
+    TransactionStatus[TransactionStatus["Rejected"] = 4] = "Rejected";
+    TransactionStatus[TransactionStatus["InvalidTransaction"] = 5] = "InvalidTransaction";
+    TransactionStatus[TransactionStatus["OnlyFeeAccepted"] = 6] = "OnlyFeeAccepted";
+})(TransactionStatus || (TransactionStatus = {}));

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

@@ -0,0 +1,3 @@
+export { TariConnection } from "./webrtc";
+export * from "./tari_permissions";
+export * from "./provider";

package/dist/providers/wallet_daemon/index.js

@@ -0,0 +1,3 @@
+export { TariConnection } from "./webrtc";
+export * from "./tari_permissions";
+export * from "./provider";

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

@@ -0,0 +1,35 @@
+import { TariPermissions } from "./tari_permissions";
+import { TariProvider } from '../index';
+import { SubmitTransactionRequest, TransactionResult, SubmitTransactionResponse, VaultBalances, TemplateDefinition, Substate, ListSubstatesResponse } from "../types";
+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;
+    permissions: TariPermissions;
+    optionalPermissions: TariPermissions;
+    webRtcConfig?: RTCConfiguration;
+    name?: string;
+    onConnection?: () => void;
+};
+export declare class WalletDaemonTariProvider implements TariProvider {
+    providerName: string;
+    params: WalletDaemonParameters;
+    client: WalletDaemonClient;
+    private constructor();
+    static build(params: WalletDaemonParameters): Promise<WalletDaemonTariProvider>;
+    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>;
+    submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
+    getTransactionResult(transactionId: string): Promise<TransactionResult>;
+    getPublicKey(branch: string, index: number): Promise<string>;
+    getTemplateDefinition(template_address: string): Promise<TemplateDefinition>;
+    getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min?: number | null, max?: number | null): Promise<VaultBalances>;
+    listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse>;
+}

package/dist/providers/wallet_daemon/provider.js

@@ -0,0 +1,173 @@
+import { TariPermissions, } from "./tari_permissions";
+import { TariConnection } from "./webrtc";
+import { TransactionStatus, } from "../types";
+import { WalletDaemonClient, stringToSubstateId, 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;
+    client;
+    constructor(params, connection) {
+        this.params = params;
+        this.client = connection;
+    }
+    static async build(params) {
+        const allPermissions = new TariPermissions();
+        allPermissions.addPermissions(params.permissions);
+        allPermissions.addPermissions(params.optionalPermissions);
+        console.log({ allPermissions });
+        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);
+    }
+    get token() {
+        return this.client.getTransport().token();
+    }
+    get tokenUrl() {
+        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}`;
+    }
+    isConnected() {
+        return this.client.getTransport().isConnected();
+    }
+    async createFreeTestCoins() {
+        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.Component,
+            public_key: res.public_key,
+            resources: []
+        };
+    }
+    async getAccount() {
+        const { account, public_key } = await this.client.accountsGetDefault({});
+        const { balances } = await this.client.accountsGetBalances({ account: { ComponentAddress: account.address.Component }, refresh: false });
+        return {
+            account_id: account.key_index,
+            address: account.address.Component,
+            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,
+                token_symbol: b.token_symbol,
+            }))
+        };
+    }
+    async getAccountBalances(componentAddress) {
+        return await this.client.accountsGetBalances({ account: { ComponentAddress: componentAddress }, refresh: true });
+    }
+    async getSubstate(substate_id) {
+        const substateId = stringToSubstateId(substate_id);
+        const { value, record } = await this.client.substatesGet({ substate_id: substateId });
+        return {
+            value,
+            address: {
+                substate_id: substateIdToString(record.substate_id),
+                version: record.version
+            }
+        };
+    }
+    async submitTransaction(req) {
+        const params = {
+            transaction: null,
+            signing_key_index: req.account_id,
+            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
+            })),
+            input_refs: [],
+            override_inputs: false,
+            is_dry_run: req.is_dry_run,
+            proof_ids: [],
+            min_epoch: null,
+            max_epoch: null,
+        };
+        const res = await this.client.submitTransaction(params);
+        return { transaction_id: res.transaction_id };
+    }
+    async getTransactionResult(transactionId) {
+        const res = await this.client.getTransactionResult({ transaction_id: transactionId });
+        return {
+            transaction_id: transactionId,
+            status: convertStringToTransactionStatus(res.status),
+            result: res.result,
+        };
+    }
+    async getPublicKey(branch, index) {
+        const res = await this.client.createKey({ branch: branch, specific_index: index });
+        return res.public_key;
+    }
+    async getTemplateDefinition(template_address) {
+        let resp = await this.client.templatesGet({ template_address });
+        return resp.template_definition;
+    }
+    async getConfidentialVaultBalances(viewKeyId, vaultId, min = null, max = null) {
+        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 };
+    }
+    async listSubstates(filter_by_template, filter_by_type, limit, offset) {
+        const resp = await this.client.substatesList({
+            filter_by_template,
+            filter_by_type,
+            limit,
+            offset
+        });
+        const substates = resp.substates.map((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) {
+    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}`);
+    }
+}