@tari-project/metamask-signer 0.5.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, The Tari Developer Community
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { TariSigner } from "@tari-project/tari-signer";
+import { SubmitTransactionRequest, TransactionResult, SubmitTransactionResponse, VaultBalances, TemplateDefinition, Substate, ListSubstatesResponse, Account } from "@tari-project/tari-signer";
+import { MetaMaskInpageProvider } from "@metamask/providers";
+import { Snap } from "./utils";
+import { ListAccountNftRequest, ListAccountNftResponse, SubstateType } from "@tari-project/typescript-bindings";
+export declare const MetamaskNotInstalled = "METAMASK_NOT_INSTALLED";
+export declare const MetamaskIsNotFlask = "METAMASK_IS_NOT_FLASK";
+export declare const TariSnapNotInstalled = "TARI_SNAP_NOT_INSTALLED";
+export declare class MetamaskTariSigner implements TariSigner {
+    signerName: string;
+    snapId: string;
+    snapVersion: string | undefined;
+    metamask: MetaMaskInpageProvider;
+    snap?: Snap;
+    metamaskConnected: boolean;
+    constructor(snapId: string, metamask: MetaMaskInpageProvider);
+    connect(): Promise<void>;
+    isConnected(): boolean;
+    createFreeTestCoins(account_id: number): Promise<Account>;
+    getAccount(): Promise<Account>;
+    getSubstate(substate_address: string): Promise<Substate>;
+    listSubstates(filter_by_template: string | null, filter_by_type: SubstateType | null, limit: number | null, offset: number | null): Promise<ListSubstatesResponse>;
+    submitTransaction(req: SubmitTransactionRequest): Promise<SubmitTransactionResponse>;
+    getTransactionResult(transactionId: string): Promise<TransactionResult>;
+    getPublicKey(_branch: string, index: number): Promise<string>;
+    getConfidentialVaultBalances(viewKeyId: number, vaultId: string, min?: number | null, max?: number | null): Promise<VaultBalances>;
+    getTemplateDefinition(template_address: string): Promise<TemplateDefinition>;
+    private metamaskRequest;
+    getNftsList(req: ListAccountNftRequest): Promise<ListAccountNftResponse>;
+}

package/dist/index.js

@@ -0,0 +1,172 @@
+import { TransactionStatus, } from "@tari-project/tari-signer";
+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 class MetamaskTariSigner {
+    signerName = "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;
+    }
+    async getNftsList(req) {
+        const resp = (await this.metamaskRequest("getNftsList", req));
+        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;
+}

package/dist/utils.d.ts

@@ -0,0 +1,38 @@
+import { MetaMaskInpageProvider } from '@metamask/providers';
+export type GetSnapsResponse = Record<string, Snap>;
+export type Snap = {
+    permissionName: string;
+    id: string;
+    version: string;
+    initialPermissions: Record<string, unknown>;
+};
+/**
+ * Get the installed snaps in MetaMask.
+ *
+ * @param provider - The MetaMask inpage provider.
+ * @returns The snaps installed in MetaMask.
+ */
+export declare const getSnaps: (provider: MetaMaskInpageProvider) => Promise<GetSnapsResponse>;
+/**
+ * Connect a snap to MetaMask.
+ *
+ * @param snapId - The ID of the snap.
+ * @param params - The params to pass with the snap to connect.
+ */
+export declare const connectSnap: (provider: MetaMaskInpageProvider, snaps: Record<string, {
+    version?: string;
+}>) => Promise<void>;
+/**
+ * Get the snap from MetaMask.
+ *
+ * @param version - The version of the snap to install (optional).
+ * @returns The snap object returned by the extension.
+ */
+export declare const getSnap: (provider: MetaMaskInpageProvider, snapId: string, version?: string) => Promise<Snap | undefined>;
+export declare const isLocalSnap: (snapId: string) => boolean;
+/**
+ * Detect if the wallet injecting the ethereum object is MetaMask Flask.
+ *
+ * @returns True if the MetaMask version is Flask, false otherwise.
+ */
+export declare const isFlask: (provider: MetaMaskInpageProvider) => Promise<boolean>;

package/dist/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/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tari-project/metamask-signer",
+  "version": "0.5.0",
+  "description": "",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@metamask/providers": "^18.2.0",
+    "@tari-project/typescript-bindings": "^1.5.1",
+    "@tari-project/tari-signer": "^0.5.0",
+    "@tari-project/tarijs-types": "^0.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "/dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b"
+  }
+}