@cartesi/cli 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/wallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAER,OAAO,EACP,KAAK,EACL,GAAG,EAEH,YAAY,EAEZ,YAAY,EACf,MAAM,MAAM,CAAC;AAsBd,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,GAAI,UAAU,sBAAsB,KAAG,KAAK,EAgBvE,CAAC;AAEF,eAAO,MAAM,uBAAuB,gEAC6B,CAAC;AAElE,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;AA2CpD,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;AA+LtB,QAAA,MAAM,aAAa,GACf,SAAS,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEA8C42L,CAAC;;;;;;;;;;;;;;sBA9C92L,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;irBA8CigW,CAAC;;;;;;;;;;;;;sBA9CngW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8CinlB,CAAC;mCAA6lC,CAAC;;;;;;;;;;;;;;;;;;;;;;sBA9CjtnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yeA8C8iuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA9ChjuC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6CxC,CAAC"}

package/dist/wallet.js

@@ -1,229 +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, cannon, mainnet, optimism, optimismSepolia, sepolia, } from "viem/chains";
-import { hexInput, selectAuto } from "./prompts.js";
-export const supportedChains = (options) => {
-    const includeDevnet = options?.includeDevnet ?? false; // default is not to show devnet
-    const includeMainnets = options?.includeMainnets ?? true; // default is true if not specified
-    const includeTestnets = options?.includeTestnets ?? true; // default is true if not specified
-    const chains = [];
-    if (includeDevnet) {
-        chains.push(cannon);
-    }
-    if (includeTestnets) {
-        chains.push(arbitrumSepolia, baseSepolia, optimismSepolia, sepolia);
-    }
-    if (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 === cannon.id;
-    return [
-        {
-            name: `Mnemonic${dev ? "" : chalk.red(" (UNSAFE)")}`,
-            value: "mnemonic",
-        },
-        {
-            name: `Private Key${dev ? "" : chalk.red(" (UNSAFE)")}`,
-            value: "private-key",
-        },
-    ];
-};
-/**
- * Test if a RPC URL for a chain is working
- * @param chain chain to test
- * @param url url to test
- * @returns true if the RPC URL is valid and chainId matches, false otherwise
- */
-const testChainUrl = async (chain, url) => {
+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 publicClient = viemCreatePublicClient({
-            transport: http(url),
-            chain,
-        });
-        const chainId = await publicClient.getChainId();
-        return chainId === chain.id;
+        const projectName = getProjectName(options);
+        const host = await getProjectPort({ projectName });
+        return `http://${host}/anvil`;
     }
     catch (e) {
-        return false;
-    }
-};
-/**
- * Test if the default RPC URL for a chain is working
- * @param chain chain to test
- * @returns true if the default RPC URL is valid, false otherwise
- */
-const testDefaultPublicClient = async (chain) => {
-    return testChainUrl(chain, chain.rpcUrls.default.http[0]);
-};
-const selectChain = async (options) => {
-    // if development mode, include anvil 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}`);
-    }
-    // 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);
-    }
-    const defaultUrl = chain.rpcUrls.default.http[0];
-    // if the chain is cannon and URL is valid, use it without asking the user
-    if (chain.id === cannon.id) {
-        const port = 6751; // XXX: how to get environment port?
-        const url = `http://127.0.0.1:${port}/anvil`;
-        if (await testChainUrl(chain, url)) {
-            return http(url);
-        }
-        if (await testDefaultPublicClient(chain)) {
-            return http(defaultUrl);
-        }
-    }
-    const url = await input({
-        message: "RPC URL",
-        default: defaultUrl,
-    });
-    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}`;
-    }
-    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,
-        });
-    }
-    if (options.mnemonicPassphrase) {
-        // mnemonic specified
-        const account = mnemonicToAccount(options.mnemonicPassphrase, {
-            addressIndex: options.mnemonicIndex,
-        });
-        // create wallet client
-        return viemCreateWalletClient({
-            account,
-            transport: publicTransport,
-            chain,
-        });
-    }
-    const wallets = walletChoices(chain);
-    const wallet = await selectAuto({
-        message: "Wallet",
-        choices: wallets,
-        discardDisabled: true,
-    });
-    if (wallet === "mnemonic") {
-        // use the publicClient transport
-        const mnemonic = await input({
-            message: "Mnemonic",
-            default: chain.id === cannon.id ? DEFAULT_DEVNET_MNEMONIC : undefined,
-        });
-        // select account from mnemonic
-        if (options.mnemonicIndex) {
-            return viemCreateWalletClient({
-                transport: publicTransport,
-                chain,
-                account: mnemonicToAccount(mnemonic, {
-                    addressIndex: options.mnemonicIndex,
-                }),
-            });
-        }
-        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,
-        });
-    }
-    if (wallet === "private-key") {
-        const privateKey = await hexInput({ message: "Private Key" });
-        const account = privateKeyToAccount(privateKey);
-        return viemCreateWalletClient({
-            transport: publicTransport,
-            chain,
-            account,
+        return await input({
+            message: "RPC URL",
+            default: `http://127.0.0.1:${PREFERRED_PORT}/anvil`,
         });
     }
-    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,6 +1,6 @@
 {
   "name": "@cartesi/cli",
-  "version": "2.0.0-alpha.13",
+  "version": "2.0.0-alpha.15",
   "description": "Cartesi CLI",
   "author": "Danilo Tuler <tuler@pobox.com>",
   "bin": {
@@ -17,56 +17,57 @@
     "/npm-shrinkwrap.json"
   ],
   "dependencies": {
-    "@commander-js/extra-typings": "^13.1.0",
-    "@inquirer/confirm": "^5.1.6",
-    "@inquirer/core": "^10.1.7",
-    "@inquirer/input": "^4.1.6",
-    "@inquirer/select": "^4.0.9",
-    "@inquirer/type": "^3.0.4",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@inquirer/confirm": "^5.1.12",
+    "@inquirer/core": "^10.1.13",
+    "@inquirer/input": "^4.1.12",
+    "@inquirer/select": "^4.2.3",
+    "@inquirer/type": "^3.0.7",
     "bytes": "^3.1.2",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
-    "commander": "^13.1.0",
-    "execa": "^9.5.2",
+    "commander": "^14.0.0",
+    "execa": "^9.6.0",
     "fs-extra": "^11.3.0",
+    "get-port": "^7.1.0",
     "giget": "^2.0.0",
-    "listr2": "^8.2.5",
+    "listr2": "^8.3.3",
     "lookpath": "^1.2.3",
-    "open": "^10.1.0",
+    "open": "^10.1.2",
     "ora": "^8.2.0",
     "p-retry": "^6.2.1",
     "progress-stream": "^2.0.0",
-    "semver": "^7.7.1",
-    "smol-toml": "^1.3.1",
+    "semver": "^7.7.2",
+    "smol-toml": "^1.3.4",
     "tmp": "^0.2.3",
-    "viem": "^2.23.6"
+    "viem": "^2.31.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@cartesi/devnet": "2.0.0-alpha.7",
-    "@cartesi/rollups": "2.0.0",
+    "@cartesi/rollups": "2.0.1",
     "@types/bytes": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.7",
-    "@types/node": "^22.13.9",
+    "@types/inquirer": "^9.0.8",
+    "@types/node": "^24.0.3",
     "@types/node-fetch": "^2.6.12",
     "@types/progress-stream": "^2.0.5",
     "@types/prompts": "^2.4.9",
-    "@types/semver": "^7.5.8",
+    "@types/semver": "^7.7.0",
     "@types/tmp": "^0.2.6",
-    "@vitest/coverage-istanbul": "^2.1.3",
-    "@wagmi/cli": "^2.2.0",
+    "@vitest/coverage-istanbul": "^3.2.3",
+    "@wagmi/cli": "^2.3.1",
     "copyfiles": "^2.4.1",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.2",
-    "vitest": "^2.1.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
     "tsconfig": "0.0.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "bugs": "https://github.com/cartesi/cli/issues",
   "types": "dist/index.d.ts",

package/dist/commands/send/eip712.d.ts

@@ -1,34 +0,0 @@
-import type { Hex, WalletClient } from "viem";
-import type { Address } from "viem/accounts";
-type SendOptions = {
-    eip712TxUrl: string;
-    chainId: number;
-    maxGasPrice: number;
-};
-export declare const DEFAULT_SEND_CONFIG: Readonly<SendOptions>;
-type TypedData = {
-    domain: {
-        name: string;
-        version: string;
-        chainId: number;
-        verifyingContract: Address;
-    };
-    types: Record<string, {
-        name: string;
-        type: string;
-    }[]>;
-    primaryType: string;
-    message: Record<string, unknown>;
-};
-/** Fetches the nonce for a given user and application */
-export declare const getNonceForEip712: (application: Address, user: Address, sendOptions: SendOptions) => Promise<number>;
-/** Submits a transaction to L2 */
-export declare const postEip712Transaction: (data: Record<string, unknown>, sendOptions: SendOptions) => Promise<{
-    id: string;
-}>;
-/** Creates a Typed Data object for signing */
-export declare const createEip712TypedData: (app: Address, data: Hex, nonce: number, sendOptions: SendOptions) => Promise<TypedData>;
-/** Sends a transaction to L2 */
-export declare const sendEip712: (walletClient: WalletClient, applicationAddress: Address, payload: Hex, sendOptions?: Partial<SendOptions>) => Promise<string>;
-export {};
-//# sourceMappingURL=eip712.d.ts.map

package/dist/commands/send/eip712.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eip712.d.ts","sourceRoot":"","sources":["../../../src/commands/send/eip712.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,KAAK,WAAW,GAAG;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAI5C,CAAC;AAEX,KAAK,SAAS,GAAG;IACb,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,EAAE,OAAO,CAAC;KAC9B,CAAC;IACF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AA2CF,yDAAyD;AACzD,eAAO,MAAM,iBAAiB,GAC1B,aAAa,OAAO,EACpB,MAAM,OAAO,EACb,aAAa,WAAW,KACzB,OAAO,CAAC,MAAM,CAMhB,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,qBAAqB,GAC9B,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,aAAa,WAAW,KACzB,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAMxB,CAAC;AAEF,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,GAC9B,KAAK,OAAO,EACZ,MAAM,GAAG,EACT,OAAO,MAAM,EACb,aAAa,WAAW,KACzB,OAAO,CAAC,SAAS,CAUnB,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,UAAU,GACnB,cAAc,YAAY,EAC1B,oBAAoB,OAAO,EAC3B,SAAS,GAAG,EACZ,cAAc,OAAO,CAAC,WAAW,CAAC,KACnC,OAAO,CAAC,MAAM,CAyBhB,CAAC"}

package/dist/commands/send/eip712.js

@@ -1,81 +0,0 @@
-export const DEFAULT_SEND_CONFIG = {
-    eip712TxUrl: "http://127.0.0.1:6751/transaction",
-    chainId: 31337,
-    maxGasPrice: 10,
-};
-const fetchJSON = async (url, options) => {
-    const response = await fetch(url, options);
-    if (!response.ok) {
-        throw new Error(`HTTP Error: ${response.status} - ${await response.text()}`);
-    }
-    return response.json();
-};
-const serializeBigInt = (_key, value) => typeof value === "bigint" ? value.toString() : value;
-const createTypedDataTemplate = (chainId, verifyingContract) => ({
-    domain: {
-        name: "Cartesi",
-        version: "0.1.0",
-        chainId,
-        verifyingContract,
-    },
-    types: {
-        EIP712Domain: [
-            { name: "name", type: "string" },
-            { name: "version", type: "string" },
-            { name: "chainId", type: "uint256" },
-            { name: "verifyingContract", type: "address" },
-        ],
-        CartesiMessage: [
-            { name: "app", type: "address" },
-            { name: "nonce", type: "uint64" },
-            { name: "max_gas_price", type: "uint128" },
-            { name: "data", type: "bytes" },
-        ],
-    },
-    primaryType: "CartesiMessage",
-    message: {},
-});
-/** Fetches the nonce for a given user and application */
-export const getNonceForEip712 = async (application, user, sendOptions) => {
-    return fetchJSON(`${sendOptions.eip712TxUrl}/nonce`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ msg_sender: user, app_contract: application }),
-    }).then((res) => res.nonce);
-};
-/** Submits a transaction to L2 */
-export const postEip712Transaction = async (data, sendOptions) => {
-    return fetchJSON(`${sendOptions.eip712TxUrl}/submit`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(data, serializeBigInt),
-    });
-};
-/** Creates a Typed Data object for signing */
-export const createEip712TypedData = async (app, data, nonce, sendOptions) => {
-    return {
-        ...createTypedDataTemplate(sendOptions.chainId, app),
-        message: {
-            app,
-            nonce,
-            data,
-            max_gas_price: BigInt(sendOptions.maxGasPrice),
-        },
-    };
-};
-/** Sends a transaction to L2 */
-export const sendEip712 = async (walletClient, applicationAddress, payload, sendOptions) => {
-    if (!walletClient.account) {
-        throw new Error("Wallet account is missing.");
-    }
-    const options = { ...DEFAULT_SEND_CONFIG, ...sendOptions };
-    const account = walletClient.account.address;
-    const nonce = await getNonceForEip712(applicationAddress, account, options);
-    const typedData = await createEip712TypedData(applicationAddress, payload, nonce, options);
-    const signature = await walletClient.signTypedData({
-        account,
-        ...typedData,
-    });
-    const { id } = await postEip712Transaction({ typedData, account, signature }, options);
-    return id;
-};

package/dist/commands/send/erc20.d.ts

@@ -1,12 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const createErc20Command: () => Command<[], {
-    token?: string | undefined;
-    amount?: string | undefined;
-}, {
-    chainId: number;
-    rpcUrl?: string | undefined;
-    mnemonic?: string | undefined;
-    mnemonicIndex: number;
-    dapp?: `0x${string}` | undefined;
-}>;
-//# sourceMappingURL=erc20.d.ts.map

package/dist/commands/send/erc20.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"erc20.d.ts","sourceRoot":"","sources":["../../../src/commands/send/erc20.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AA8DtD,eAAO,MAAM,kBAAkB;;;;;;;;;EAgD9B,CAAC"}

package/dist/commands/send/erc20.js

@@ -1,75 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-import input from "@inquirer/input";
-import ora from "ora";
-import { erc20Abi, getAddress, isAddress, parseEther, } from "viem";
-import { erc20PortalAbi, erc20PortalAddress } from "../../contracts.js";
-import { connect, getInputApplicationAddress, } from "../send.js";
-const readToken = async (publicClient, address) => {
-    const args = { abi: erc20Abi, address };
-    const symbol = await publicClient.readContract({
-        ...args,
-        functionName: "symbol",
-    });
-    const name = await publicClient.readContract({
-        ...args,
-        functionName: "name",
-    });
-    const decimals = await publicClient.readContract({
-        ...args,
-        functionName: "decimals",
-    });
-    return {
-        name,
-        symbol,
-        decimals,
-    };
-};
-const ercValidator = (publicClient) => async (value) => {
-    if (!isAddress(value)) {
-        return "Invalid address";
-    }
-    try {
-        await readToken(publicClient, value);
-    }
-    catch (e) {
-        return "Invalid token";
-    }
-    return true;
-};
-export const createErc20Command = () => {
-    return new Command("erc20")
-        .description("Sends ERC-20 deposits to the application, optionally in interactive mode.")
-        .configureHelp({ showGlobalOptions: true })
-        .option("--token <address>", "token address")
-        .option("--amount <number>", "amount to send")
-        .action(async (options, command) => {
-        const sendOptions = command.optsWithGlobals();
-        // connect to RPC provider
-        const { publicClient, walletClient } = await connect(sendOptions);
-        // get dapp address from local node, or ask
-        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
-        const tokenAddress = options.token && isAddress(options.token)
-            ? getAddress(options.token)
-            : (await input({
-                message: "Token address",
-                validate: ercValidator(publicClient),
-            }));
-        const amount = options.amount || (await input({ message: "Amount" }));
-        const { request } = await publicClient.simulateContract({
-            address: erc20PortalAddress,
-            abi: erc20PortalAbi,
-            functionName: "depositERC20Tokens",
-            args: [
-                tokenAddress,
-                applicationAddress,
-                parseEther(amount), // XXX: we need to use the token decimals here!
-                "0x",
-            ],
-            account: walletClient.account,
-        });
-        const hash = await walletClient.writeContract(request);
-        const progress = ora("Sending input...").start();
-        await publicClient.waitForTransactionReceipt({ hash });
-        progress.succeed(`Input sent: ${hash}`);
-    });
-};

package/dist/commands/send/erc721.d.ts

@@ -1,12 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const createErc721Command: () => Command<[], {
-    token?: string | undefined;
-    tokenId?: string | undefined;
-}, {
-    chainId: number;
-    rpcUrl?: string | undefined;
-    mnemonic?: string | undefined;
-    mnemonicIndex: number;
-    dapp?: `0x${string}` | undefined;
-}>;
-//# sourceMappingURL=erc721.d.ts.map

package/dist/commands/send/erc721.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/commands/send/erc721.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAuDtD,eAAO,MAAM,mBAAmB;;;;;;;;;EAuD/B,CAAC"}