@tari-project/tarijs 0.1.20

package/dist/index.js

@@ -0,0 +1,1063 @@
+export { MetaMaskInpageProvider } from '@metamask/providers';
+import { WalletDaemonClient, stringToSubstateId, substateIdToString } from '@tari-project/wallet_jrpc_client';
+
+function toHexString(byteArray) {
+    if (Array.isArray(byteArray)) {
+        return Array.from(byteArray, function (byte) {
+            return ('0' + (byte & 0xff).toString(16)).slice(-2);
+        }).join('');
+    }
+    if (byteArray === undefined) {
+        return 'undefined';
+    }
+    // object might be a tagged object
+    if (byteArray['@@TAGGED@@'] !== undefined) {
+        return toHexString(byteArray['@@TAGGED@@'][1]);
+    }
+    return 'Unsupported type';
+}
+function fromHexString(hexString) {
+    let res = [];
+    for (let i = 0; i < hexString.length; i += 2) {
+        res.push(Number('0x' + hexString.substring(i, i + 2)));
+    }
+    return res;
+}
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    fromHexString: fromHexString,
+    toHexString: toHexString
+});
+
+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 = {}));
+
+/**
+ * Get the installed snaps in MetaMask.
+ *
+ * @param provider - The MetaMask inpage provider.
+ * @returns The snaps installed in MetaMask.
+ */
+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.
+ */
+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.
+ */
+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;
+    }
+};
+/**
+ * Detect if the wallet injecting the ethereum object is MetaMask Flask.
+ *
+ * @returns True if the MetaMask version is Flask, false otherwise.
+ */
+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;
+    }
+};
+
+const MetamaskNotInstalled = 'METAMASK_NOT_INSTALLED';
+const MetamaskIsNotFlask = 'METAMASK_IS_NOT_FLASK';
+const TariSnapNotInstalled = 'TARI_SNAP_NOT_INSTALLED';
+class MetamaskTariProvider {
+    providerName = "Metamask";
+    snapId;
+    snapVersion;
+    metamask;
+    snap;
+    metamaskConnected;
+    constructor(snapId, metamask) {
+        this.snapId = snapId;
+        this.snapVersion = undefined;
+        this.metamask = metamask;
+        this.metamaskConnected = false;
+    }
+    async connect() {
+        // check that the metamask provider is valid
+        if (!this.metamask || !this.metamask.isMetaMask) {
+            throw MetamaskNotInstalled;
+        }
+        // check that flask is installed
+        if (!isFlask(this.metamask)) {
+            throw MetamaskIsNotFlask;
+        }
+        // connect to the tari snap
+        // this will request MetaMask the installation of the tari snap if it's not already installed
+        await connectSnap(this.metamask, { [this.snapId]: { version: this.snapVersion } });
+        // store the tari snap reference
+        const snap = await getSnap(this.metamask, this.snapId);
+        if (!snap) {
+            // this should olny happen if the user didn't accept the tari snap in the previous step
+            throw TariSnapNotInstalled;
+        }
+        this.snap = snap;
+        this.metamaskConnected = true;
+    }
+    isConnected() {
+        return this.metamaskConnected;
+    }
+    async createFreeTestCoins(account_id) {
+        const res = await this.metamaskRequest('getFreeTestCoins', {
+            amount: 1000000,
+            account_id,
+            fee: 2000
+        });
+        return {
+            account_id,
+            address: res.address,
+            public_key: res.public_key,
+            resources: []
+        };
+    }
+    async getAccount() {
+        return await this.metamaskRequest('getAccountData', { account_id: 0 });
+    }
+    async 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', {
+            filter_by_template,
+            filter_by_type,
+            limit,
+            offset,
+        });
+        return res;
+    }
+    async submitTransaction(req) {
+        const params = {
+            instructions: req.instructions,
+            fee_instructions: req.fee_instructions,
+            input_refs: req.input_refs,
+            required_substates: req.required_substates || [],
+            is_dry_run: req.is_dry_run,
+        };
+        const resp = await this.metamaskRequest('sendTransaction', params);
+        if (!resp) {
+            throw new Error("Failed to submit transaction to metamask snap: empty response");
+        }
+        if (resp.error) {
+            throw new Error(`Failed to submit transaction to metamask snap: ${resp.error}`);
+        }
+        return { transaction_id: resp.transaction_id };
+    }
+    async getTransactionResult(transactionId) {
+        // This request returns the response from the indexer get_transaction_result request
+        const resp = await this.metamaskRequest('getTransactionResult', { transaction_id: transactionId });
+        if (!resp) {
+            throw new Error("Failed to get transaction result from metamask snap: empty response");
+        }
+        if (resp.result === "Pending") {
+            return {
+                transaction_id: transactionId,
+                status: TransactionStatus.Pending,
+                result: null
+            };
+        }
+        if (!resp?.result?.Finalized) {
+            throw new Error("Transaction result was not pending nor finalized");
+        }
+        const newStatus = convertToStatus(resp.result.Finalized);
+        return {
+            transaction_id: transactionId,
+            status: newStatus,
+            result: resp.result.Finalized.execution_result.finalize
+        };
+    }
+    async getPublicKey(_branch, 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', {
+            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 => {
+            if (!resp) {
+                throw new Error("Template not found");
+            }
+            return resp.definition;
+        });
+    }
+    async metamaskRequest(method, params) {
+        console.log("Metamask request:", method, params);
+        const resp = await this.metamask.request({
+            method: 'wallet_invokeSnap',
+            params: {
+                snapId: this.snapId,
+                request: {
+                    method,
+                    params
+                }
+            },
+        });
+        console.log("Metamask response:", resp);
+        if (!resp) {
+            throw new Error("Metamask request failed: empty response");
+        }
+        return resp;
+    }
+}
+function convertToStatus(result) {
+    // Ref: https://github.com/tari-project/tari-dan/blob/bb0b31139b770aacd7bb49af865543aa4a9e2de4/dan_layer/wallet/sdk/src/apis/transaction.rs
+    if (result.final_decision !== "Commit") {
+        return TransactionStatus.Rejected;
+    }
+    // if (!result?.result?.Finalized) {
+    //     throw new Error("Transaction result was finalized but no result was returned");
+    // }
+    //
+    // if (result.finalize.AcceptFeeRejectRest) {
+    //     return TransactionStatus.OnlyFeeAccepted;
+    // }
+    return TransactionStatus.Accepted;
+}
+
+class SignaligServer {
+    _token;
+    _server_url;
+    constructor(server_url) {
+        console.log(server_url);
+        if (server_url !== undefined) {
+            this._server_url = server_url;
+        }
+        else {
+            this._server_url = "http://localhost:9100";
+        }
+    }
+    async initToken(permissions) {
+        this._token = await this.authLogin(permissions);
+    }
+    get token() {
+        return this._token;
+    }
+    async jsonRpc(method, token, params) {
+        console.log('jsonRpc', method, token, params);
+        let id = 0;
+        id += 1;
+        let address = this._server_url;
+        let headers = { 'Content-Type': 'application/json' };
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        let response = await fetch(address, {
+            method: 'POST',
+            body: JSON.stringify({
+                method: method,
+                jsonrpc: '2.0',
+                id: id,
+                params: params || {},
+            }),
+            headers: headers
+        });
+        let json = await response.json();
+        if (json.error) {
+            throw json.error;
+        }
+        return json.result;
+    }
+    async authLogin(permissions) {
+        return await this.jsonRpc("auth.login", undefined, permissions);
+    }
+    async storeIceCandidate(ice_candidate) {
+        return await this.jsonRpc("add.offer_ice_candidate", this._token, ice_candidate);
+    }
+    async storeOffer(offer) {
+        return await this.jsonRpc("add.offer", this._token, offer.sdp);
+    }
+    async getAnswer() {
+        return await this.jsonRpc("get.answer", this._token);
+    }
+    async getIceCandidates() {
+        return await this.jsonRpc("get.answer_ice_candidates", this._token);
+    }
+}
+class TariConnection {
+    _peerConnection;
+    _dataChannel;
+    _signalingServer;
+    _callbacks;
+    _offer;
+    _walletToken;
+    // This is public so that user can directly set the onopen callback that will be called once the data channel is open.
+    onopen;
+    onConnection;
+    constructor(signalig_server_url, config) {
+        this._peerConnection = new RTCPeerConnection(config || this.config());
+        this._dataChannel = this._peerConnection.createDataChannel("tari-data");
+        this._signalingServer = new SignaligServer(signalig_server_url);
+        this._callbacks = {};
+    }
+    get token() {
+        if (this._walletToken) {
+            return this._walletToken;
+        }
+        return this._signalingServer.token;
+    }
+    async init(permissions, onConnection) {
+        this.onConnection = onConnection;
+        await this._signalingServer.initToken(permissions);
+        // Setup our receiving end
+        this._dataChannel.onmessage = (message) => {
+            let response = JSON.parse(message.data);
+            console.log('response', response);
+            if (!this._callbacks[response.id]) {
+                console.error("No callback found for id", response.id);
+                return;
+            }
+            // The response should contain id, to identify the Promise.resolve, that is waiting for this result
+            let [resolve, reject] = this._callbacks[response.id];
+            delete this._callbacks[response.id];
+            if (response.payload?.error) {
+                reject(new Error(response.payload.error));
+            }
+            else {
+                resolve(response.payload);
+            }
+        };
+        this._dataChannel.onopen = () => {
+            // This should be removed before the release, but it's good for debugging.
+            console.log("Data channel is open!");
+            this.sendMessage({ id: 0, jsonrpc: "2.0", method: "get.token", params: {} }, this._signalingServer.token)
+                .then((walletToken) => {
+                if (typeof walletToken !== 'string') {
+                    throw Error('Received invalid JWT from wallet daemon');
+                }
+                console.log("Wallet JWT received: ", walletToken);
+                this._walletToken = walletToken;
+                if (this.onConnection) {
+                    this.onConnection(this);
+                }
+            });
+        };
+        this._peerConnection.onicecandidate = (event) => {
+            console.log('event', event);
+            if (event?.candidate) {
+                console.log("ICE ", event.candidate);
+                console.log("ICE ", typeof event.candidate);
+                // Store the ice candidates, so the other end can add them
+                this._signalingServer.storeIceCandidate(event.candidate).then((resp) => {
+                    // This should be removed before the release, but it's good for debugging.
+                    console.log("Candidate stored", resp);
+                });
+            }
+        };
+        // Create offer
+        this._offer = await this._peerConnection.createOffer();
+        // Set the offer as our local sdp, at this point it will start getting the ice candidates
+        this._peerConnection.setLocalDescription(this._offer);
+        // Store the offer so the other end can set it as a remote sdp
+        this._signalingServer.storeOffer(this._offer).then((resp) => {
+            // This should be removed before the release, but it's good for debugging.
+            console.log("Offer stored", resp);
+        });
+        await this.signalingServerPolling();
+    }
+    async setAnswer() {
+        // This is called once the other end got the offer and ices and created and store an answer and its ice candidates
+        // We get its answer sdp
+        let sdp = await this._signalingServer.getAnswer();
+        // And its ice candidates
+        let iceCandidates = await this._signalingServer.getIceCandidates();
+        // For us the answer is remote sdp
+        let answer = new RTCSessionDescription({ sdp, type: "answer" });
+        this._peerConnection.setRemoteDescription(answer);
+        // We add all the ice candidates to connect, the other end is doing the same with our ice candidates
+        for (const iceCandidate of iceCandidates) {
+            this._peerConnection.addIceCandidate(iceCandidate);
+        }
+    }
+    async signalingServerPolling() {
+        // no need to keep retrying if we are already connected to the wallet
+        if (this._peerConnection.connectionState === "connected") {
+            return;
+        }
+        try {
+            await this.setAnswer();
+        }
+        catch (error) {
+            // we don't need to do anything on error, as the execution will be retried later
+            console.error(error);
+        }
+        // try again later
+        setTimeout(async () => {
+            await this.signalingServerPolling();
+        }, 2000);
+    }
+    isConnected() {
+        return this._dataChannel.readyState === "open";
+    }
+    // If the last parameter has timeout property e.g. {timeout:1000}, it set the timeout for this call.
+    async sendMessage(request, token, timeout_secs = null) {
+        if (!this.isConnected) {
+            throw new Error("WALLET_DAEMON_NOT_CONNECTED");
+        }
+        // This should be removed before the release, but it's good for debugging.
+        console.log(request, 'timeout', timeout_secs);
+        return new Promise((resolve, reject) => {
+            // We store the resolve callback for this request,
+            // so once the data channel receives a response we know where to return the data
+            this._callbacks[request.id] = [resolve, reject];
+            if (timeout_secs) {
+                // If the user set a timeout which set it here so the promise will be rejected if not fulfilled in time.
+                setTimeout(() => {
+                    delete this._callbacks[request.id];
+                    reject(new Error("Timeout"));
+                }, timeout_secs * 1000);
+            }
+            // Make the actual call to the wallet daemon
+            this._dataChannel.send(JSON.stringify({ token, ...request }));
+        });
+    }
+    // This is our default config, use can set their own stun/turn server in the constructor.
+    config() {
+        return { iceServers: [{ urls: "stun:stun.l.google.com:19302" }] };
+    }
+}
+
+class Hash {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}
+var TAG;
+(function (TAG) {
+    TAG[TAG["ComponentAddress"] = 128] = "ComponentAddress";
+    TAG[TAG["Metadata"] = 129] = "Metadata";
+    TAG[TAG["NonFungibleAddress"] = 130] = "NonFungibleAddress";
+    TAG[TAG["ResourceAddress"] = 131] = "ResourceAddress";
+    TAG[TAG["VaultId"] = 132] = "VaultId";
+    TAG[TAG["TransactionReceipt"] = 134] = "TransactionReceipt";
+    TAG[TAG["FeeClaim"] = 135] = "FeeClaim";
+})(TAG || (TAG = {}));
+class Tagged {
+    value;
+    tag;
+    constructor(tag, value) {
+        this.tag = tag;
+        this.value = value;
+    }
+    toJSON() {
+        return { "@@TAGGED@@": [this.tag, this.value] };
+    }
+}
+class ResourceAddress {
+    tagged;
+    constructor(hash) {
+        this.tagged = new Tagged(TAG.ResourceAddress, hash);
+    }
+    toJSON() {
+        return this.tagged.toJSON();
+    }
+}
+class UnclaimedConfidentialOutputAddress {
+    hash;
+    constructor(hash) {
+        this.hash = hash;
+    }
+    toJSON() {
+        return this.hash.toJSON();
+    }
+}
+class U256 {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}
+class NonFungibleId {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        switch (typeof this.value) {
+            case 'string':
+                return { 'string': this.value };
+            case 'number':
+                return { 'Uint64': this.value };
+        }
+        return { 'U256': this.value };
+    }
+}
+class NonFungibleAddressContents {
+    resource_address;
+    id;
+    constructor(resource_address, id) {
+        this.resource_address = resource_address;
+        this.id = id;
+    }
+    toJSON() {
+        return { "resource_address": this.resource_address, "id": this.id };
+    }
+}
+class NonFungibleAddress {
+    tagged;
+    constructor(value) {
+        this.tagged = new Tagged(TAG.NonFungibleAddress, value);
+    }
+    toJSON() {
+        return this.tagged.toJSON();
+    }
+}
+class NonFungibleIndexAddress {
+    resource_address;
+    index;
+    constructor(resource_address, index) {
+        this.resource_address = resource_address;
+        this.index = index;
+    }
+    toJSON() {
+        return { "resource_address": this.resource_address, "index": this.index };
+    }
+}
+class ComponentAddress {
+    tagged;
+    constructor(hash) {
+        this.tagged = new Tagged(TAG.ComponentAddress, hash);
+    }
+    toJSON() {
+        return this.tagged.toJSON();
+    }
+}
+class VaultId {
+    tagged;
+    constructor(hash) {
+        this.tagged = new Tagged(TAG.VaultId, hash);
+    }
+    toJSON() {
+        return this.tagged.toJSON();
+    }
+}
+class SubstateAddress {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        if (this.value instanceof ComponentAddress) {
+            return { "Component": this.value };
+        }
+        else if (this.value instanceof ResourceAddress) {
+            return { "Resource": this.value };
+        }
+        else if (this.value instanceof VaultId) {
+            return { "Vault": this.value };
+        }
+        else if (this.value instanceof UnclaimedConfidentialOutputAddress) {
+            return { "UnclaimedConfidentialOutput": this.value };
+        }
+        else if (this.value instanceof NonFungibleAddress) {
+            return { "NonFungible": this.value };
+        }
+        else if (this.value instanceof NonFungibleIndexAddress) {
+            return { "NonFungibleIndex": this.value };
+        }
+        throw "Unknown type";
+    }
+}
+class TariPermissionAccountBalance {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        console.log("stringify", this.value);
+        return { "AccountBalance": this.value };
+    }
+}
+class TariPermissionAccountInfo {
+    constructor() { }
+    toJSON() {
+        return "AccountInfo";
+    }
+}
+class TariPermissionAccountList {
+    value;
+    constructor(value) {
+        if (value === undefined) {
+            this.value = null;
+        }
+        else {
+            this.value = value;
+        }
+    }
+    toJSON() {
+        console.log('JSON TariPermissionAccountList', this.value);
+        if (this.value === undefined) {
+            return { "AccountList": null };
+        }
+        else {
+            return { "AccountList": this.value };
+        }
+    }
+}
+class TariPermissionKeyList {
+    constructor() { }
+    toJSON() {
+        return "KeyList";
+    }
+}
+class TariPermissionTransactionGet {
+    constructor() { }
+    toJSON() {
+        return "TransactionGet";
+    }
+}
+class TariPermissionTransactionSend {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        console.log('JSON TariPermissionTransactionSend', this.value);
+        if (this.value === undefined) {
+            return { "TransactionSend": null };
+        }
+        else {
+            return { "TransactionSend": this.value };
+        }
+    }
+}
+class TariPermissionGetNft {
+    value0;
+    value1;
+    constructor(value0, value1) {
+        this.value0 = value0;
+        this.value1 = value1;
+    }
+    toJSON() {
+        return { "GetNft": [this.value0, this.value1] };
+    }
+}
+class TariPermissionNftGetOwnershipProof {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return { "NftGetOwnershipProof": this.value };
+    }
+}
+class TariPermissionTransactionsGet {
+    constructor() { }
+    toJSON() {
+        return "TransactionGet";
+    }
+}
+class TariPermissionSubstatesRead {
+    constructor() { }
+    toJSON() {
+        return "SubstatesRead";
+    }
+}
+class TariPermissionTemplatesRead {
+    constructor() { }
+    toJSON() {
+        return "TemplatesRead";
+    }
+}
+// export enum TariPermission {
+//   AccountBalance = "AccountBalance",
+//   AccountInfo = "AccountInfo",
+//   AccountList = "AccountList",
+//   KeyList = "KeyList",
+//   TransactionGet = "TransactionGet",
+//   TransactionSend = "TransactionSend",
+//   GetNft = "GetNft",
+//   NftGetOwnershipProof = "NftGetOwnershipProof",
+//   TransactionsGet = "TransactionsGet",
+//   SubstatesRead = "SubstatesRead",
+//   TemplatesRead = "TemplatesRead",
+// }
+class TariPermissions {
+    permissions;
+    constructor() {
+        this.permissions = [];
+    }
+    addPermission(permission) {
+        this.permissions.push(permission);
+        return this;
+    }
+    addPermissions(other) {
+        this.permissions.push(...other.permissions);
+        return this;
+    }
+    toJSON() {
+        return this.permissions;
+    }
+}
+// TariPermissionType.prototype.toString = function () {
+//   return "wtf"
+// }
+
+class WebRtcRpcTransport {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    static new(connection) {
+        return new WebRtcRpcTransport(connection);
+    }
+    token() {
+        return this.connection.token;
+    }
+    isConnected() {
+        return this.connection.isConnected();
+    }
+    sendRequest(data, options) {
+        return this.connection.sendMessage(data, options.token);
+    }
+}
+
+const WalletDaemonNotConnected = 'WALLET_DAEMON_NOT_CONNECTED';
+const Unsupported = 'UNSUPPORTED';
+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}`);
+    }
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ComponentAddress: ComponentAddress,
+    Hash: Hash,
+    NonFungibleAddress: NonFungibleAddress,
+    NonFungibleAddressContents: NonFungibleAddressContents,
+    NonFungibleId: NonFungibleId,
+    NonFungibleIndexAddress: NonFungibleIndexAddress,
+    ResourceAddress: ResourceAddress,
+    SubstateAddress: SubstateAddress,
+    get TAG () { return TAG; },
+    Tagged: Tagged,
+    TariConnection: TariConnection,
+    TariPermissionAccountBalance: TariPermissionAccountBalance,
+    TariPermissionAccountInfo: TariPermissionAccountInfo,
+    TariPermissionAccountList: TariPermissionAccountList,
+    TariPermissionGetNft: TariPermissionGetNft,
+    TariPermissionKeyList: TariPermissionKeyList,
+    TariPermissionNftGetOwnershipProof: TariPermissionNftGetOwnershipProof,
+    TariPermissionSubstatesRead: TariPermissionSubstatesRead,
+    TariPermissionTemplatesRead: TariPermissionTemplatesRead,
+    TariPermissionTransactionGet: TariPermissionTransactionGet,
+    TariPermissionTransactionSend: TariPermissionTransactionSend,
+    TariPermissionTransactionsGet: TariPermissionTransactionsGet,
+    TariPermissions: TariPermissions,
+    U256: U256,
+    UnclaimedConfidentialOutputAddress: UnclaimedConfidentialOutputAddress,
+    Unsupported: Unsupported,
+    VaultId: VaultId,
+    WalletDaemonNotConnected: WalletDaemonNotConnected,
+    WalletDaemonTariProvider: WalletDaemonTariProvider
+});
+
+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] });
+    }
+}
+
+export { MetamaskTariProvider, TariPermissions, TariUniverseProvider, TransactionStatus, WalletDaemonTariProvider, index as permissions, utils };
+//# sourceMappingURL=index.js.map