npm - @everyprotocol/every-cli - Versions diffs - 0.1.15 → 0.1.16 - Mend

@everyprotocol/every-cli 0.1.15 → 0.1.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/abi.js CHANGED Viewed

@@ -27,15 +27,15 @@ export const abi = {
         ...parseAbi(["function setContract(uint64 id) external view returns (address code)"]),
         ...loadNonFuncAbiItems("SetRegistry"),
     ],
-    mint: [
+    minterMint: [
         ...parseAbi([
             "function mint(address to, address set, uint64 id, bytes memory data, bytes memory auth, uint32 policy) payable",
         ]),
         ...loadNonFuncAbiItems("ObjectMinter"),
         ...loadNonFuncAbiItems("ISet"),
     ],
-    create: [
-        ...parseAbi(["function create(address to, uint64 id0, bytes calldata data) payable"]),
+    setMint: [
+        ...parseAbi(["function mint(address to, uint64 id0, bytes calldata data) payable"]),
         ...loadNonFuncAbiItems("ISet"),
     ],
     relation: [

package/dist/cmds/object.js CHANGED Viewed

@@ -1,175 +1,330 @@
-import { Argument, Command } from "commander";
-import { createPublicClient, http, parseUnits } from "viem";
+import { Argument, Option, Command } from "commander";
 import { parseAbiItem, erc1155Abi, erc721Abi } from "viem";
 import { abi } from "../abi.js";
 import { submitSimulation } from "../ethereum.js";
 import { Logger } from "../logger.js";
-import { parseBigInt, parseNode3, parseNode4, parseSID } from "../parsers.js";
-import { CommandGenDefaults, getCommandGen } from "../cmdgen.js";
+import { parseAddress, parseBigInt, parseEther, parseHexData, parseInt, parseNode3, parseNode4, parseSID, } from "../parsers.js";
 import { FromOpts } from "../from-opts.js";
 import { coerceValue } from "../utils.js";
-const objectRelateCmd = new Command()
-    .name("relate")
-    .description("Link a tail object to a head object through a relation")
-    .addWriteOptions()
-    .argument("<tail>", "tail node, in form of [[data.]grant.]set.id", parseNode4)
-    .argument("<rel>", "relation ID", parseBigInt)
-    .argument("<head>", "head node in form of [grant.]set.id, ", parseNode3)
-    .action(async function () {
-    await relateAction(this, "relate");
-});
-const objectUnrelateCmd = new Command()
-    .name("unrelate")
-    .description("Unlinks a tail object from a head object")
-    .addWriteOptions()
-    .argument("<tail>", "tail node, in form of [[data.]grant.]set.id", parseNode4)
-    .argument("<rel>", "relation ID", parseBigInt)
-    .argument("<head>", "head node in form of [grant.]set.id, ", parseNode3)
-    .action(async function () {
-    await relateAction(this, "unrelate");
-});
-const objectMintCmd = new Command()
-    .name("mint")
-    .description("Mint an object via the object minter or directly from the set")
-    .option("--to <address>", "specify the recipient")
-    .option("--value <amount>", "the amount of ETH to send together", "0")
-    .option("--auth <data>", "authorization data for a permissioned mint", "0x")
-    .option("--policy <index>", "the index number of the mint policy", "0")
-    .option("--no-minter", "mint directly from set contract instead of using ObjectMinter")
-    .addWriteOptions()
-    .argument("<sid>", "scoped object ID, in form of set.id (e.g., 17.1)")
-    .argument("[data]", "additional input data", "0x")
-    .action(mintAction);
-const objectSendCmd = new Command("send")
-    .description("Call a function by signature (dry-run: prints calldata)")
-    .option("--sig <sig>", "Function signature, e.g. 'transfer(address,uint256)'")
-    .argument("<args...>", "Function arguments (arrays/tuples as JSON)")
-    .addWriteOptions()
-    .action(sendAction);
-const cmdGenConfig = {
-    getFuncName: (cmdName) => cmdName,
-    getAbiFuncs: (funcName) => abi.funcs.setContract.filter((i) => i.name == funcName),
-    // eslint-disable-next-line
-    getAbiNonFuncs: (funcName) => [...abi.nonFuncs.setContract],
-    // eslint-disable-next-line
-    getContract: async function (conf, args, abiFunc) {
-        const publicClient = createPublicClient({ transport: http(conf.rpc) });
-        const address = await publicClient.readContract({
-            address: conf.contracts.SetRegistry,
-            abi: abi.setContract,
-            functionName: "setContract",
-            args: [args[0].set],
-        });
-        return address;
-    },
-    // eslint-disable-next-line
-    getFuncArgs: function (args, abiFunc) {
-        return abiFunc.name == "uri" ? args.slice(1) : [args[0].id, ...args.slice(1)];
-    },
-    getCmdArgs: function (abiFunc) {
-        const sid = new Argument(`<sid>`, "sid of the object").argParser(parseSID);
-        const args0 = CommandGenDefaults.getCmdArgs(abiFunc);
-        return abiFunc.name == "uri" ? [sid] : [sid, ...args0.slice(1)];
-    },
-};
-const cmdGen = getCommandGen(cmdGenConfig);
-const writeCmds = "upgrade,touch,transfer".split(",");
-const readCmds = "owner,descriptor,snapshot,uri".split(",");
+import { outputOptions, universe as universeOption, writeOptions } from "../commander-patch.js";
+const sidArg = new Argument("<sid>", "Object SID, in form of {set}.{id}").argParser(parseSID);
+const tailArg = new Argument("<tail>", "Tail object, in form of [[data.]grant.]set.id").argParser(parseNode4);
+const relArg = new Argument("<rel>", "Relation ID").argParser(parseBigInt);
+const headArg = new Argument("<head>", "Head object, in form of [grant.]set.id").argParser(parseNode3);
 export const objectCmd = new Command("object")
     .description("manage objects")
-    .addCommands(writeCmds.map(cmdGen))
-    .addCommand(objectMintCmd)
-    .addCommand(objectRelateCmd)
-    .addCommand(objectUnrelateCmd)
-    .addCommand(objectSendCmd)
-    .addCommands(readCmds.map(cmdGen));
-async function mintAction() {
-    const opts = this.opts();
-    const args0 = this.args;
-    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
-    const setRegistry = conf.contracts["SetRegistry"];
-    const account = walletClient.account;
-    const [set, id] = args0[0].split(".");
-    const setContract = (await publicClient.readContract({
-        address: setRegistry,
-        abi: abi.setContract,
-        functionName: "setContract",
-        args: [BigInt(set)],
-    }));
-    const value = parseUnits(opts.value || "0", 18);
-    const recipientAddress = (opts.to || account.address);
-    const mintData = (args0[1] || "0x");
-    const simulation = opts.minter
-        ? {
-            address: conf.contracts["ObjectMinter"],
-            abi: abi.mint,
-            functionName: "mint",
-            args: [recipientAddress, setContract, BigInt(id), mintData, opts.auth || "0x", Number(opts.policy || "0")],
-            account,
-            value,
+    .addCommand(genMintCmd())
+    .addCommand(genUpgradeCmd())
+    .addCommand(genTouchCmd())
+    .addCommand(genTransferCmd())
+    .addCommand(genSendCmd())
+    .addCommand(genRelateCmd())
+    .addCommand(genUnrelateCmd())
+    .addCommand(genOwnerCmd())
+    .addCommand(genDescriptorCmd())
+    .addCommand(genSnapshotCmd())
+    .addCommand(genUriCmd());
+function genUpgradeCmd() {
+    const cmdArgs = [sidArg];
+    const cmdOpts = [
+        new Option("--krev <rev>", "Upgrade kind to specified revison ").argParser(parseInt),
+        new Option("--srev <rev>", "Upgrade set to specified revison").argParser(parseInt),
+        ...writeOptions,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const { set, id } = this.processedArgs[0];
+        const address = await getSetContract(set, publicClient, conf);
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const functionName = "upgrade";
+        const args = [id, opts.krev ?? 0, opts.srev ?? 0];
+        const account = walletClient.account;
+        const simulation = { address, abi: abi_, functionName, args, account };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("upgrade")
+        .description("Upgrade an object")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function genTouchCmd() {
+    const cmdArgs = [sidArg];
+    const cmdOpts = [...writeOptions, ...outputOptions];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const { set, id } = this.processedArgs[0];
+        const address = await getSetContract(set, publicClient, conf);
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const functionName = "touch";
+        const args = [id];
+        const account = walletClient.account;
+        const simulation = { address, abi: abi_, functionName, args, account };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("touch").description("Touch an object").addArguments(cmdArgs).addOptions(cmdOpts).action(action);
+}
+function genTransferCmd() {
+    const cmdArgs = [sidArg, new Argument("<to>", "Recipient address")];
+    const cmdOpts = [...writeOptions, ...outputOptions];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const { set, id } = this.processedArgs[0];
+        const address = await getSetContract(set, publicClient, conf);
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const functionName = "transfer";
+        const args = [id, this.processedArgs[1]];
+        const account = walletClient.account;
+        const simulation = { address, abi: abi_, functionName, args, account };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("transfer")
+        .description("Transfer an object")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function genMintCmd() {
+    const cmdArgs = [new Argument("<sid0>", "Object SID, in form of {set}.{id0}").argParser(parseSID)];
+    const cmdOpts = [
+        new Option("--to <address>", "Recipient address").argParser(parseAddress),
+        new Option("--data <data>", "Extra mint data").argParser(parseHexData),
+        new Option("--value <amount>", "Send an amount of ETH").argParser(parseEther),
+        new Option("--minter", "Via ObjectMinter instead"),
+        new Option("--policy <index>", "Index of the mint policy to search afterward").argParser(parseInt),
+        new Option("--auth <data>", "Authorization data for permission").argParser(parseHexData),
+        ...writeOptions,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const { set, id } = this.processedArgs[0];
+        const account = walletClient.account;
+        const to = opts.to ?? account?.address;
+        const value = opts.value ?? 0;
+        const data = opts.data ?? "0x";
+        const functionName = "mint";
+        let simulation;
+        if (!opts.minter) {
+            const address = await getSetContract(set, publicClient, conf);
+            const args = [to, id, data];
+            simulation = { address, abi: abi.setMint, functionName, args, value, account };
+        }
+        else {
+            const setAddress = await getSetContract(set, publicClient, conf);
+            const address = conf.contracts.ObjectMinter;
+            const authData = opts.auth ?? "0x";
+            const policy = opts.policy ?? 0;
+            const args = [to, setAddress, id, data, authData, policy];
+            simulation = { address, abi: abi.minterMint, functionName, args, value, account };
         }
-        : {
-            address: setContract,
-            abi: abi.create,
-            functionName: "create",
-            args: [recipientAddress, BigInt(id), mintData],
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("mint").description("Mint an object").addArguments(cmdArgs).addOptions(cmdOpts).action(action);
+}
+function genSendCmd() {
+    const cmdArgs = [
+        new Argument("<sig>", "Signature, e.g. 'transfer(address,uint256)'"),
+        new Argument("[args...]", "Arguments"),
+    ];
+    const cmdOpts = [
+        new Option("--value <amount>", "the amount of ETH to send").argParser(parseEther),
+        ...writeOptions,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const sig = this.processedArgs[0];
+        const item = parseAbiItem(`function ${sig}`);
+        if (item.type !== "function")
+            throw new Error(`Not a function signature: ${sig}`);
+        const abiFunc = item;
+        const params = abiFunc.inputs ?? [];
+        const args0 = this.args.slice(0);
+        if (args0.length !== params.length)
+            throw new Error(`Invalid argument count: expected ${params.length}, got ${args0.length}`);
+        const sidPos = params.findIndex((p) => p.type == "uint64");
+        if (sidPos == -1)
+            throw new Error("No uint64 found in signature");
+        const { set, id } = parseSID(args0[sidPos]);
+        args0[sidPos] = id.toString();
+        const args = args0.map((a, i) => coerceValue(a, params[i]));
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const address = await getSetContract(set, publicClient, conf);
+        const account = walletClient.account;
+        const value = opts.value ?? 0;
+        const simulation = {
+            address,
+            abi: [abiFunc, ...abi.nonFuncs.setContract, ...erc1155Abi, ...erc721Abi],
+            functionName: abiFunc.name,
+            args,
             account,
             value,
         };
-    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command("send")
+        .description("Send a transaction to set contract")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
 }
-async function relateAction(cmd, functionName) {
-    const opts = cmd.opts();
-    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
-    const address = conf.contracts["OmniRegistry"];
-    const simulation = {
-        address,
-        abi: abi.relation,
-        functionName,
-        args: cmd.args,
-        account: walletClient.account,
-    };
-    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+function genOwnerCmd() {
+    const cmdName = "owner";
+    const cmdArgs = [sidArg];
+    const cmdOpts = [universeOption, ...outputOptions];
+    async function action() {
+        const opts = this.opts();
+        const { set, id } = this.processedArgs[0];
+        const { conf, publicClient } = FromOpts.toReadEthereum(opts);
+        const address = await getSetContract(set, publicClient, conf);
+        const args = [id];
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const result = await publicClient.readContract({ address, abi: abi_, functionName: cmdName, args });
+        const console = new Logger(opts);
+        console.log(result);
+        console.result(result);
+    }
+    return new Command("owner").description("Get object owner").addArguments(cmdArgs).addOptions(cmdOpts).action(action);
+}
+function genDescriptorCmd() {
+    const cmdName = "descriptor";
+    const cmdArgs = [sidArg];
+    const cmdOpts = [
+        new Option("--rev <rev>", "At the specified revision").argParser(parseInt),
+        universeOption,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const { set, id } = this.processedArgs[0];
+        const { conf, publicClient } = FromOpts.toReadEthereum(opts);
+        const address = await getSetContract(set, publicClient, conf);
+        const args = [id, opts.rev ?? 0];
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const result = await publicClient.readContract({ address, abi: abi_, functionName: cmdName, args });
+        const console = new Logger(opts);
+        console.log(result);
+        console.result(result);
+    }
+    return new Command("descriptor")
+        .description("Get object descriptor")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function genSnapshotCmd() {
+    const cmdName = "snapshot";
+    const cmdArgs = [sidArg];
+    const cmdOpts = [
+        new Option("--rev <rev>", "At the specified revision").argParser(parseInt),
+        universeOption,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const { set, id } = this.processedArgs[0];
+        const { conf, publicClient } = FromOpts.toReadEthereum(opts);
+        const address = await getSetContract(set, publicClient, conf);
+        const args = [id, opts.rev ?? 0];
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const result = await publicClient.readContract({ address, abi: abi_, functionName: cmdName, args });
+        const console = new Logger(opts);
+        console.log(result);
+        console.result(result);
+    }
+    return new Command("snapshot")
+        .description("Get object snapshot")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function genUriCmd() {
+    const cmdName = "uri";
+    const cmdArgs = [sidArg];
+    const cmdOpts = [
+        new Option("--rev <rev>", "At the specified revision").argParser(parseInt),
+        universeOption,
+        ...outputOptions,
+    ];
+    async function action() {
+        const opts = this.opts();
+        const { set, id } = this.processedArgs[0];
+        const { conf, publicClient } = FromOpts.toReadEthereum(opts);
+        const address = await getSetContract(set, publicClient, conf);
+        const args = []; // eslint-disable-line @typescript-eslint/no-explicit-any
+        const abi_ = [...abi.funcs.setContract, ...abi.nonFuncs.setContract];
+        const result0 = (await publicClient.readContract({
+            address,
+            abi: abi_,
+            functionName: cmdName,
+            args,
+        })); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const result = opts.rev ? interpolate(result0, id, opts.rev) : result0;
+        const console = new Logger(opts);
+        console.log(result);
+        console.result(result);
+    }
+    return new Command("uri").description("Get object URI").addArguments(cmdArgs).addOptions(cmdOpts).action(action);
 }
-async function sendAction() {
-    const opts = this.opts();
-    const args0 = this.args;
-    const { sig } = this.opts();
-    if (!sig) {
-        console.error("Error: --sig is required (e.g. --sig 'transfer(address,uint256)')");
-        this.exitOverride();
-        return;
+function genRelateCmd() {
+    const cmdArgs = [tailArg, relArg, headArg];
+    const cmdOpts = [...writeOptions, ...outputOptions];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const simulation = {
+            address: conf.contracts.OmniRegistry,
+            abi: abi.relation,
+            functionName: "relate",
+            args: this.processedArgs,
+            account: walletClient.account,
+        };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+    }
+    return new Command()
+        .name("relate")
+        .description("Link a tail object to a head object")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function genUnrelateCmd() {
+    const cmdArgs = [tailArg, relArg, headArg];
+    const cmdOpts = [...writeOptions, ...outputOptions];
+    async function action() {
+        const opts = this.opts();
+        const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
+        const simulation = {
+            address: conf.contracts.OmniRegistry,
+            abi: abi.relation,
+            functionName: "unrelate",
+            args: this.processedArgs,
+            account: walletClient.account,
+        };
+        await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
     }
-    const item = parseAbiItem(`function ${sig}`);
-    if (item.type !== "function")
-        throw new Error(`Not a function signature: ${sig}`);
-    const abiFunc = item;
-    const params = abiFunc.inputs ?? [];
-    if (args0.length !== params.length)
-        throw new Error(`Argument count mismatch: expected ${params.length}, got ${args0.length}`);
-    const sidIndex = params.findIndex((p) => p.type == "uint64");
-    if (sidIndex == -1)
-        throw new Error("SID type(uint64) not found in signature");
-    const [setId, objectId] = args0[sidIndex].split(".");
-    args0[sidIndex] = objectId;
-    const args = args0.map((a, i) => coerceValue(a, params[i]));
-    const { publicClient, walletClient, conf } = await FromOpts.toWriteEthereum(opts);
-    const setRegistry = conf.contracts["SetRegistry"];
-    const account = walletClient.account;
-    const setContract = (await publicClient.readContract({
-        address: setRegistry,
-        abi: abi.funcs.setRegistry,
+    return new Command()
+        .name("unrelate")
+        .description("Unlink a tail object from a head object")
+        .addArguments(cmdArgs)
+        .addOptions(cmdOpts)
+        .action(action);
+}
+function interpolate(tmpl, id, rev) {
+    return tmpl.replace(/\{id\}/g, String(id)).replace(/\{rev\}/g, String(rev));
+}
+async function getSetContract(set, publicClient, conf) {
+    const address = await publicClient.readContract({
+        address: conf.contracts.SetRegistry,
+        abi: abi.setContract,
         functionName: "setContract",
-        args: [BigInt(setId)],
-    }));
-    const value = parseUnits(opts.value ?? "0", 18);
-    const simulation = {
-        address: setContract,
-        abi: [abiFunc, ...abi.nonFuncs.setContract, ...erc1155Abi, ...erc721Abi],
-        functionName: abiFunc.name,
-        args: args,
-        account,
-        value,
-    };
-    await submitSimulation(simulation, publicClient, walletClient, new Logger(opts));
+        args: [set],
+    });
+    return address;
 }

package/dist/cmds/set.js CHANGED Viewed

@@ -37,12 +37,12 @@ export const setCmd = new Command("set")
     .addCommands(adminCmds.map(getCommandGen(adminCmdConfig)))
     .addCommands(userCmds.map(getCommandGen(userCmdConfig)));
 function genDeployCmd() {
-    const args = [
-        new Argument(`<contract>`, "Artifact ID of the contract"),
+    const cmdArgs = [
+        new Argument(`<artifact>`, "Artifact path of the contract"),
         new Argument(`[args...]`, "Constructor arguments"),
     ];
-    const options = [
-        new Option("--artifact-dir <dir>", "Artifact directory").default("./out"),
+    const cmdOpts = [
+        new Option("-o, --out <dir>", "Artifact output directory").default("./out"),
         ...writeOptions,
         ...outputOptions,
     ];
@@ -104,8 +104,8 @@ function genDeployCmd() {
         console.result(result);
     }
     return new Command("deploy")
-        .description("Deploy a set contract")
-        .addOptions(options)
-        .addArguments(args)
+        .description("Deploy a contract")
+        .addOptions(cmdOpts)
+        .addArguments(cmdArgs)
         .action(action);
 }

package/dist/parsers.js CHANGED Viewed

@@ -1,12 +1,21 @@
 import { u8aFixLength } from "@polkadot/util";
 import { decodeAddress } from "@polkadot/util-crypto";
 import { InvalidArgumentError } from "commander";
+import { getAddress, hexToBytes, isHex, parseUnits } from "viem";
 export function parseBigInt(arg) {
     try {
         return BigInt(arg);
     }
     catch (e /* eslint-disable-line */) {
-        throw new InvalidArgumentError("invalid bigint");
+        throw new InvalidArgumentError("Invalid bigint");
+    }
+}
+export function parseInt(arg) {
+    try {
+        return Number.parseInt(arg);
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError("Invalid integer");
     }
 }
 export function parseSID(arg) {
@@ -17,16 +26,44 @@ export function parseSID(arg) {
         return { set, id };
     }
     catch (e /* eslint-disable-line */) {
-        throw new InvalidArgumentError(`invalid SID: ${arg}`);
+        throw new InvalidArgumentError(`Invalid SID: ${arg}`);
+    }
+}
+export function parseEther(arg) {
+    try {
+        return parseUnits(arg, 18);
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError(`Invalid ether amount: ${arg}`);
     }
 }
-export function parseAccountId(address) {
+export function parseAccountId(arg) {
     try {
-        return u8aFixLength(decodeAddress(address), 256);
+        return u8aFixLength(decodeAddress(arg), 256);
     }
     catch (e /* eslint-disable-line */) {
-        throw new InvalidArgumentError("invalid account ID");
+        throw new InvalidArgumentError("Invalid account ID");
+    }
+}
+export function parseAddress(arg) {
+    try {
+        return getAddress(arg);
+    }
+    catch (e /* eslint-disable-line */) {
+        throw new InvalidArgumentError("Invalid address");
+    }
+}
+export function parseBytes32(arg) {
+    if (isHex(arg, { strict: true }) && hexToBytes(arg).length == 32) {
+        return arg;
+    }
+    throw new InvalidArgumentError("Invalid bytes32");
+}
+export function parseHexData(arg) {
+    if (isHex(arg, { strict: true })) {
+        return arg;
     }
+    throw new InvalidArgumentError("Invalid hex data");
 }
 export function parseNode4(arg) {
     const parts = arg.split(".");

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@everyprotocol/every-cli",
   "type": "module",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "repository": {
     "type": "git",
     "url": "https://github.com/everyprotocol/cli.git"