@cartesi/cli 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/wallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,OAAO,EACP,KAAK,EACL,GAAG,EAEH,YAAY,EAEZ,YAAY,EAKf,MAAM,MAAM,CAAC;AAiBd,MAAM,MAAM,sBAAsB,GAAG;IACjC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,eAAe,aAAc,sBAAsB,KAAG,KAAK,EAoBvE,CAAC;AAEF,eAAO,MAAM,uBAAuB,gEAC6B,CAAC;AAElE,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;AAepD,MAAM,WAAW,qBAAqB;IAClC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC5B,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,KACzB,OAAO,CAAC,OAAO,CAAC,CAAC;AAkLtB,QAAA,MAAM,aAAa,YACN,qBAAqB,KAC/B,OAAO,CAAC;IACP,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;CAC9B,CAuBA,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,OAAO;;;;;;;;;;kBAHoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOvC,CAAC;AAsBH,eAAO,MAAM,OAAO,GAAU,SAAS;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;;;;;;;;;;kBAhCuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEA8Cg3L,CAAC;;;;;;;;;;;;;;sBA9Cl3L,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;irBA8CgnW,CAAC;;;;;;;;;;;;;sBA9ClnW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8CgulB,CAAC;mCAA6lC,CAAC;;;;;;;;;;;;;;;;;;;;;;sBA9Ch0nB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yeA8C6puC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA9C/puC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6CxC,CAAC"}

package/dist/wallet.js

@@ -1,204 +1,41 @@
 import input from "@inquirer/input";
-import chalk from "chalk";
-import { formatUnits, http, createPublicClient as viemCreatePublicClient, createWalletClient as viemCreateWalletClient, } from "viem";
-import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
-import { arbitrum, arbitrumSepolia, base, baseSepolia, foundry, mainnet, optimism, optimismSepolia, sepolia, } from "viem/chains";
-import { hexInput, selectAuto } from "./prompts.js";
-export const supportedChains = (options) => {
-    options = options || {
-        includeDevnet: false, // default is not to show devnet
-        includeMainnets: true,
-        includeTestnets: true,
-    };
-    options.includeTestnets = options.includeTestnets ?? true; // default is true if not specified
-    options.includeMainnets = options.includeMainnets ?? true; // default is true if not specified
-    const chains = [];
-    if (options.includeDevnet) {
-        chains.push(foundry);
-    }
-    if (options.includeTestnets) {
-        chains.push(arbitrumSepolia, baseSepolia, optimismSepolia, sepolia);
-    }
-    if (options.includeMainnets) {
-        chains.push(arbitrum, base, mainnet, optimism);
-    }
-    return chains;
-};
-export const DEFAULT_DEVNET_MNEMONIC = "test test test test test test test test test test test junk";
-const walletChoices = (chain) => {
-    const dev = chain.id === foundry.id;
-    return [
-        {
-            name: `Mnemonic${dev ? "" : chalk.red(" (UNSAFE)")}`,
-            value: "mnemonic",
-        },
-        {
-            name: `Private Key${dev ? "" : chalk.red(" (UNSAFE)")}`,
-            value: "private-key",
-        },
-    ];
-};
-const selectChain = async (options) => {
-    // if development mode, include foundry as an option
-    const chains = supportedChains({ includeDevnet: true });
-    if (options.chain) {
-        const chain = options.chain;
-        if (chains.findIndex((c) => c.id === chain.id) >= 0) {
-            return options.chain;
-        }
-        throw new Error(`Unsupported chainId ${options.chain.id}`);
-    }
-    else {
-        // allow user to select from list
-        const choices = chains.map((chain) => ({
-            name: chain.name,
-            value: chain,
-        }));
-        return await selectAuto({
-            message: "Chain",
-            choices,
-            pageSize: choices.length,
-            discardDisabled: true,
-        });
-    }
-};
-const selectTransport = async (options, chain) => {
-    // use user provided url (in args) or try to use default one from chain, or ask for one
-    if (options.rpcUrl) {
-        return http(options.rpcUrl);
-    }
-    else {
-        const url = await input({
+import { createTestClient, defineChain, http, publicActions, walletActions, } from "viem";
+import { cannon } from "viem/chains";
+import { getProjectName } from "./base.js";
+import { PREFERRED_PORT } from "./config.js";
+import { getProjectPort } from "./exec/rollups.js";
+export const cartesi = defineChain({
+    ...cannon,
+    name: "Cartesi Devnet",
+    testnet: true,
+});
+const getRpcUrl = async (options) => {
+    // if rpcUrl is provided, use it
+    if (options.rpcUrl)
+        return options.rpcUrl;
+    // otherwise, try to resolve host:port of the docker project
+    try {
+        const projectName = getProjectName(options);
+        const host = await getProjectPort({ projectName });
+        return `http://${host}/anvil`;
+    }
+    catch {
+        return await input({
             message: "RPC URL",
-            default: chain.rpcUrls.default.http[0],
-        });
-        return http(url);
-    }
-};
-const createPublicClient = async (chain, transport) => {
-    const publicClient = viemCreatePublicClient({ transport, chain });
-    // check if chainId matches
-    const chainId = await publicClient.getChainId();
-    if (chainId !== chain.id) {
-        throw new Error(`Chain of provided RPC URL (${chainId}) does not match selected chain (${chain.id}))`);
-    }
-    return publicClient;
-};
-/**
- * Format the balance of an account for display
- * @param account account to format the balance for
- * @param publicClient client to query the balance
- * @returns formatted balance string
- */
-const addressBalanceLabel = async (address, publicClient) => {
-    const chain = publicClient.chain;
-    if (chain) {
-        // query balance using provider
-        const balance = await publicClient.getBalance({ address });
-        // format balance
-        const symbol = chain.nativeCurrency.symbol;
-        const balanceStr = formatUnits(balance, chain.nativeCurrency.decimals);
-        let balanceLabel = chalk.bold(`${balanceStr} ${symbol}`);
-        // display in red if balance is zero
-        if (balance === 0n) {
-            balanceLabel = chalk.red(balanceLabel);
-        }
-        return `${address} ${balanceLabel}`;
-    }
-    else {
-        return address;
-    }
-};
-const createWalletClient = async (options, chain, publicClient, publicTransport) => {
-    if (options.privateKey) {
-        // private key specified
-        const account = privateKeyToAccount(options.privateKey);
-        return viemCreateWalletClient({
-            account,
-            transport: publicTransport,
-            chain,
-        });
-    }
-    else if (options.mnemonicPassphrase) {
-        // mnemonic specified
-        const account = mnemonicToAccount(options.mnemonicPassphrase, {
-            addressIndex: options.mnemonicIndex,
-        });
-        // create wallet client
-        return viemCreateWalletClient({
-            account,
-            transport: publicTransport,
-            chain,
-        });
-    }
-    else {
-        const wallets = walletChoices(chain);
-        const wallet = await selectAuto({
-            message: "Wallet",
-            choices: wallets,
-            discardDisabled: true,
+            default: `http://127.0.0.1:${PREFERRED_PORT}/anvil`,
         });
-        if (wallet === "mnemonic") {
-            // use the publicClient transport
-            const mnemonic = await input({
-                message: "Mnemonic",
-                default: chain.id === 31337 ? DEFAULT_DEVNET_MNEMONIC : undefined,
-            });
-            // select account from mnemonic
-            if (options.mnemonicIndex) {
-                return viemCreateWalletClient({
-                    transport: publicTransport,
-                    chain,
-                    account: mnemonicToAccount(mnemonic, {
-                        addressIndex: options.mnemonicIndex,
-                    }),
-                });
-            }
-            else {
-                const choices = await Promise.all([...Array(10)].map(async (_, addressIndex) => {
-                    const account = mnemonicToAccount(mnemonic, {
-                        addressIndex,
-                    });
-                    const name = await addressBalanceLabel(account.address, publicClient);
-                    return { name, value: account };
-                }));
-                const account = await selectAuto({
-                    message: "Account",
-                    choices,
-                    pageSize: choices.length,
-                });
-                return viemCreateWalletClient({
-                    transport: publicTransport,
-                    chain,
-                    account,
-                });
-            }
-        }
-        else if (wallet === "private-key") {
-            const privateKey = await hexInput({ message: "Private Key" });
-            const account = privateKeyToAccount(privateKey);
-            return viemCreateWalletClient({
-                transport: publicTransport,
-                chain,
-                account,
-            });
-        }
-        throw new Error(`Unsupported wallet ${wallet}`);
     }
 };
-const createClients = async (options) => {
-    // select chain
-    const chain = await selectChain(options);
-    // select RPC URL
-    const transport = await selectTransport(options, chain);
-    // create public client
-    const publicClient = await createPublicClient(chain, transport);
-    // create wallet client
-    const walletClient = await createWalletClient(options, chain, publicClient, transport);
-    return {
-        chain,
-        publicClient,
-        walletClient,
-    };
+export const connect = async (options) => {
+    // resolve rpc url
+    const rpcUrl = await getRpcUrl(options);
+    // create test client
+    const client = createTestClient({
+        chain: cartesi,
+        mode: "anvil",
+        transport: http(rpcUrl),
+    })
+        .extend(publicActions)
+        .extend(walletActions);
+    return client;
 };
-export default createClients;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@cartesi/cli",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.20",
   "description": "Cartesi CLI",
   "author": "Danilo Tuler <tuler@pobox.com>",
   "bin": {
-    "cartesi": "./bin/run.js"
+    "cartesi": "./dist/index.js"
   },
   "type": "module",
   "homepage": "https://github.com/cartesi/cli",
@@ -14,80 +14,61 @@
   "files": [
     "/bin",
     "/dist",
-    "/npm-shrinkwrap.json",
-    "/oclif.manifest.json"
+    "/npm-shrinkwrap.json"
   ],
   "dependencies": {
-    "@inquirer/confirm": "^5.0.0",
-    "@inquirer/core": "^10.0.0",
-    "@inquirer/input": "^4.0.0",
-    "@inquirer/select": "^4.0.0",
-    "@inquirer/type": "^3.0.0",
-    "@oclif/core": "^4.0.29",
-    "@oclif/plugin-help": "^6.2.15",
-    "@oclif/plugin-plugins": "^5.4.15",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@inquirer/confirm": "^5.1.18",
+    "@inquirer/core": "^10.2.2",
+    "@inquirer/input": "^4.2.4",
+    "@inquirer/select": "^4.3.4",
+    "@inquirer/type": "^3.0.8",
     "bytes": "^3.1.2",
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
-    "execa": "^9.4.1",
-    "fs-extra": "^11.2.0",
-    "giget": "^1.2.3",
-    "lookpath": "^1.2.2",
-    "open": "^10.1.0",
-    "ora": "^8.1.0",
+    "commander": "^14.0.1",
+    "execa": "^9.6.0",
+    "fs-extra": "^11.3.2",
+    "get-port": "^7.1.0",
+    "giget": "^2.0.0",
+    "listr2": "^9.0.4",
+    "lookpath": "^1.2.3",
+    "ora": "^9.0.0",
+    "p-retry": "^7.0.0",
     "progress-stream": "^2.0.0",
-    "semver": "^7.6.3",
-    "smol-toml": "^1.3.0",
-    "tmp": "^0.2.3",
-    "viem": "^2.21.27"
+    "semver": "^7.7.2",
+    "smol-toml": "^1.4.2",
+    "tmp": "^0.2.5",
+    "viem": "^2.37.6"
   },
   "devDependencies": {
-    "@sunodo/wagmi-plugin-hardhat-deploy": "^0.3.0",
-    "@types/bytes": "^3.1.4",
+    "@biomejs/biome": "^2.2.4",
+    "@cartesi/devnet": "2.0.0-alpha.7",
+    "@cartesi/rollups": "2.0.1",
+    "@types/bytes": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^22.7.6",
-    "@types/node-fetch": "^2.6.11",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^24.5.1",
+    "@types/node-fetch": "^2.6.13",
     "@types/progress-stream": "^2.0.5",
     "@types/prompts": "^2.4.9",
-    "@types/semver": "^7.5.8",
+    "@types/semver": "^7.7.1",
     "@types/tmp": "^0.2.6",
-    "@vitest/coverage-istanbul": "^2.1.3",
-    "@wagmi/cli": "^2.1.16",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "@wagmi/cli": "^2.5.1",
     "copyfiles": "^2.4.1",
-    "eslint": "^8.57.0",
-    "eslint-config-oclif": "^5.2.1",
-    "eslint-config-oclif-typescript": "^3.1.12",
     "npm-run-all": "^4.1.5",
-    "oclif": "^4.15.9",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "tslib": "^2.8.0",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.3",
-    "@cartesi/devnet": "2.0.0-alpha.1",
-    "@cartesi/eslint-config": "0.0.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4",
     "tsconfig": "0.0.0"
   },
-  "oclif": {
-    "bin": "cartesi",
-    "dirname": "cartesi",
-    "commands": "./dist/commands",
-    "plugins": [
-      "@oclif/plugin-help"
-    ],
-    "topicSeparator": " ",
-    "macos": {
-      "identifier": "io.cartesi.cli"
-    }
-  },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "bugs": "https://github.com/cartesi/cli/issues",
-  "keywords": [
-    "oclif"
-  ],
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "run-s clean codegen compile copy-files",
@@ -95,8 +76,9 @@
     "codegen": "run-p codegen:wagmi",
     "codegen:wagmi": "wagmi generate",
     "compile": "tsc -p tsconfig.build.json",
+    "postcompile": "chmod +x dist/index.js",
     "copy-files": "copyfiles -u 1 \"src/**/*.yaml\" \"src/**/*.env\" \"src/**/*.txt\" dist",
-    "lint": "eslint \"src/**/*.ts*\"",
+    "lint": "biome lint",
     "posttest": "pnpm lint",
     "test": "vitest"
   }

package/bin/dev.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\dev" %*

package/bin/dev.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node --no-warnings=ExperimentalWarning --loader ts-node/esm
-
-import oclif from "@oclif/core";
-import path from "node:path";
-import url from "node:url";
-import { register } from "ts-node";
-
-// In dev mode -> use ts-node and dev plugins
-process.env.NODE_ENV = "development";
-
-const project = path.join(
-    path.dirname(url.fileURLToPath(import.meta.url)),
-    "..",
-    "tsconfig.json"
-);
-register({ project });
-
-// In dev mode, always show stack traces
-oclif.settings.debug = true;
-
-// Start the CLI
-oclif
-    .run(process.argv.slice(2), import.meta.url)
-    .then(oclif.flush)
-    .catch(oclif.Errors.handle);

package/bin/run.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\run" %*

package/bin/run.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-import oclif from "@oclif/core";
-
-oclif
-    .run(process.argv.slice(2), import.meta.url)
-    .then(oclif.flush)
-    .catch(oclif.Errors.handle);

package/dist/baseCommand.d.ts

@@ -1,22 +0,0 @@
-import { Command, Interfaces } from "@oclif/core";
-import { Address, Hash } from "viem";
-import { Config } from "./config.js";
-export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)["baseFlags"] & T["flags"]>;
-export type Args<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
-export type AddressBook = Record<string, Address>;
-export declare abstract class BaseCommand<T extends typeof Command> extends Command {
-    protected flags: Flags<T>;
-    protected args: Args<T>;
-    protected getServiceState(projectName: string, serviceName: string): Promise<string | undefined>;
-    protected getContextPath(...paths: string[]): string;
-    protected getApplicationConfig(configPath: string): Config;
-    protected getMachineHash(): Hash | undefined;
-    protected logPrompt({ title, value }: {
-        title: string;
-        value: string;
-    }): void;
-    protected getApplicationAddress(): Promise<Address>;
-    protected getAddressBook(): Promise<AddressBook>;
-    init(): Promise<void>;
-}
-//# sourceMappingURL=baseCommand.d.ts.map

package/dist/baseCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"baseCommand.d.ts","sourceRoot":"","sources":["../src/baseCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKlD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAsB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,MAAM,EAAS,MAAM,aAAa,CAAC;AAiB5C,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,OAAO,OAAO,IAAI,UAAU,CAAC,aAAa,CAClE,CAAC,OAAO,WAAW,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CACjD,CAAC;AACF,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,OAAO,OAAO,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAChF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAElD,8BAAsB,WAAW,CAAC,CAAC,SAAS,OAAO,OAAO,CAAE,SAAQ,OAAO;IACvE,SAAS,CAAC,KAAK,EAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3B,SAAS,CAAC,IAAI,EAAG,IAAI,CAAC,CAAC,CAAC,CAAC;cAET,eAAe,CAC3B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAe9B,SAAS,CAAC,cAAc,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM;IAIpD,SAAS,CAAC,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAM1D,SAAS,CAAC,cAAc,IAAI,IAAI,GAAG,SAAS;IAY5C,SAAS,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;cAItD,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;cAKzC,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;IAiCzC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAYrC"}

package/dist/baseCommand.js

@@ -1,92 +0,0 @@
-import { Command } from "@oclif/core";
-import chalk from "chalk";
-import { execa } from "execa";
-import fs from "fs";
-import path from "path";
-import { getAddress, isHash } from "viem";
-import { parse } from "./config.js";
-import { applicationFactoryAddress, authorityFactoryAddress, erc1155BatchPortalAddress, erc1155SinglePortalAddress, erc20PortalAddress, erc721PortalAddress, etherPortalAddress, inputBoxAddress, selfHostedApplicationFactoryAddress, testMultiTokenAddress, testNftAddress, testTokenAddress, } from "./contracts.js";
-export class BaseCommand extends Command {
-    async getServiceState(projectName, serviceName) {
-        // get service information
-        const { stdout } = await execa("docker", [
-            "compose",
-            "--project-name",
-            projectName,
-            "ps",
-            serviceName,
-            "--format",
-            "json",
-        ]);
-        const ps = stdout ? JSON.parse(stdout) : undefined;
-        return ps?.State;
-    }
-    getContextPath(...paths) {
-        return path.join(".cartesi", ...paths);
-    }
-    getApplicationConfig(configPath) {
-        return fs.existsSync(configPath)
-            ? parse(fs.readFileSync(configPath).toString())
-            : parse("");
-    }
-    getMachineHash() {
-        // read hash of the cartesi machine snapshot, if one exists
-        const hashPath = this.getContextPath("image", "hash");
-        if (fs.existsSync(hashPath)) {
-            const hash = fs.readFileSync(hashPath).toString("hex");
-            if (isHash(`0x${hash}`)) {
-                return `0x${hash}`;
-            }
-        }
-        return undefined;
-    }
-    logPrompt({ title, value }) {
-        this.log(`${chalk.green("?")} ${title} ${chalk.cyan(value)}`);
-    }
-    async getApplicationAddress() {
-        // fixed value, as we do deterministic deployment with a zero hash
-        return getAddress("0xab7528bb862fb57e8a2bcd567a2e929a0be56a5e");
-    }
-    async getAddressBook() {
-        const applicationAddress = await this.getApplicationAddress();
-        // build rollups contracts address book
-        const contracts = {
-            Application: applicationAddress,
-            ApplicationFactory: applicationFactoryAddress,
-            AuthorityFactory: authorityFactoryAddress,
-            EntryPointV06: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-            EntryPointV07: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
-            ERC1155BatchPortal: erc1155BatchPortalAddress,
-            ERC1155SinglePortal: erc1155SinglePortalAddress,
-            ERC20Portal: erc20PortalAddress,
-            ERC721Portal: erc721PortalAddress,
-            EtherPortal: etherPortalAddress,
-            InputBox: inputBoxAddress,
-            LightAccountFactory: "0x00004EC70002a32400f8ae005A26081065620D20",
-            SelfHostedApplicationFactory: selfHostedApplicationFactoryAddress,
-            SimpleAccountFactory: "0x9406Cc6185a346906296840746125a0E44976454",
-            SmartAccountFactory: "0x000000a56Aaca3e9a4C479ea6b6CD0DbcB6634F5",
-            KernelFactoryV2: "0x5de4839a76cf55d0c90e2061ef4386d962E15ae3",
-            KernelFactoryV3: "0x6723b44Abeec4E71eBE3232BD5B455805baDD22f",
-            KernelFactoryV3_1: "0xaac5D4240AF87249B3f71BC8E4A2cae074A3E419",
-            TestToken: testTokenAddress,
-            TestNFT: testNftAddress,
-            TestMultiToken: testMultiTokenAddress,
-            VerifyingPaymasterV06: "0x28ec0633192d0cBd9E1156CE05D5FdACAcB93947",
-            VerifyingPaymasterV07: "0xc5c97885C67F7361aBAfD2B95067a5bBdA603608",
-        };
-        return contracts;
-    }
-    async init() {
-        await super.init();
-        const { args, flags } = await this.parse({
-            flags: this.ctor.flags,
-            baseFlags: super.ctor.baseFlags,
-            args: this.ctor.args,
-            enableJsonFlag: this.ctor.enableJsonFlag,
-            strict: this.ctor.strict,
-        });
-        this.flags = flags;
-        this.args = args;
-    }
-}

package/dist/commands/deploy/index.d.ts

@@ -1,12 +0,0 @@
-import { BaseCommand } from "../../baseCommand.js";
-export default class Deploy extends BaseCommand<typeof Deploy> {
-    static summary: string;
-    static description: string;
-    static examples: string[];
-    static flags: {
-        hosting: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        webapp: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<import("url").URL, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
-    run(): Promise<void>;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/deploy/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/deploy/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC1D,MAAM,CAAC,OAAO,SAA2C;IAEzD,MAAM,CAAC,WAAW,SACoD;IAEtE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,KAAK;;;MAWV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAiEpC"}