@fastxyz/cli 1.0.0

package/dist/chunk-T7HRTMD7.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-77HVPD4G.js";
+
+// src/services/storage/database.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+import {
+  drizzle
+} from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { Context, Effect, Layer } from "effect";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  accounts: () => accounts,
+  customNetworks: () => customNetworks,
+  history: () => history,
+  metadata: () => metadata
+});
+import {
+  blob,
+  index,
+  integer,
+  sqliteTable,
+  text
+} from "drizzle-orm/sqlite-core";
+var accounts = sqliteTable("accounts", {
+  name: text("name").primaryKey(),
+  fastAddress: text("fast_address").notNull(),
+  evmAddress: text("evm_address").notNull(),
+  encryptedKey: blob("encrypted_key", { mode: "buffer" }).notNull(),
+  encrypted: integer("encrypted", { mode: "boolean" }).notNull().default(true),
+  isDefault: integer("is_default", { mode: "boolean" }).notNull().default(false),
+  createdAt: text("created_at").notNull()
+});
+var history = sqliteTable(
+  "history",
+  {
+    hash: text("hash").primaryKey(),
+    type: text("type").notNull().default("transfer"),
+    from: text("from").notNull(),
+    to: text("to").notNull(),
+    amount: text("amount").notNull(),
+    formatted: text("formatted").notNull(),
+    tokenName: text("token_name").notNull(),
+    tokenId: text("token_id").notNull(),
+    network: text("network").notNull(),
+    status: text("status").notNull(),
+    timestamp: text("timestamp").notNull(),
+    explorerUrl: text("explorer_url"),
+    route: text("route").notNull().default("fast"),
+    chainId: integer("chain_id")
+  },
+  (table) => [index("idx_history_timestamp").on(table.timestamp)]
+);
+var customNetworks = sqliteTable("custom_networks", {
+  name: text("name").primaryKey(),
+  config: text("config").notNull()
+});
+var metadata = sqliteTable("metadata", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull()
+});
+
+// src/errors/account.ts
+import { Data } from "effect";
+var AccountExistsError = class extends Data.TaggedError("AccountExistsError") {
+  exitCode = 2;
+  errorCode = "ACCOUNT_EXISTS";
+  get message() {
+    return `Account "${this.name}" already exists`;
+  }
+};
+var AccountNotFoundError = class extends Data.TaggedError(
+  "AccountNotFoundError"
+) {
+  exitCode = 2;
+  errorCode = "ACCOUNT_NOT_FOUND";
+  get message() {
+    return `Account "${this.name}" not found`;
+  }
+};
+var NoDefaultAccountError = class extends Data.TaggedError(
+  "NoDefaultAccountError"
+) {
+  exitCode = 2;
+  errorCode = "NO_DEFAULT_ACCOUNT";
+  get message() {
+    return "No default account found. Create one with `fast account create` or set a default with `fast account set-default`.";
+  }
+};
+var DefaultAccountError = class extends Data.TaggedError(
+  "DefaultAccountError"
+) {
+  exitCode = 2;
+  errorCode = "DEFAULT_ACCOUNT";
+  get message() {
+    return `Cannot delete "${this.name}" because it is the default account. Use \`fast account set-default\` first.`;
+  }
+};
+var PasswordRequiredError = class extends Data.TaggedError(
+  "PasswordRequiredError"
+) {
+  exitCode = 2;
+  errorCode = "PASSWORD_REQUIRED";
+  get message() {
+    return "Password required. Use --password, FAST_PASSWORD env var, or run in interactive mode.";
+  }
+};
+var WrongPasswordError = class extends Data.TaggedError("WrongPasswordError") {
+  exitCode = 2;
+  errorCode = "WRONG_PASSWORD";
+  get message() {
+    return "Incorrect password";
+  }
+};
+
+// src/errors/io.ts
+import { Data as Data2 } from "effect";
+var DatabaseError = class extends Data2.TaggedError("DatabaseError") {
+  exitCode = 1;
+  errorCode = "DATABASE_ERROR";
+};
+var FileIOError = class extends Data2.TaggedError("FileIOError") {
+  exitCode = 1;
+  errorCode = "FILE_IO_ERROR";
+};
+var InternalError = class extends Data2.TaggedError("InternalError") {
+  exitCode = 1;
+  errorCode = "INTERNAL_ERROR";
+};
+var FastSdkError = class extends Data2.TaggedError("FastSdkError") {
+  exitCode = 1;
+  errorCode = "FAST_SDK_ERROR";
+};
+
+// src/errors/network.ts
+import { Data as Data3 } from "effect";
+var NetworkExistsError = class extends Data3.TaggedError("NetworkExistsError") {
+  exitCode = 2;
+  errorCode = "NETWORK_EXISTS";
+  get message() {
+    return `Network "${this.name}" already exists`;
+  }
+};
+var NetworkNotFoundError = class extends Data3.TaggedError(
+  "NetworkNotFoundError"
+) {
+  exitCode = 2;
+  errorCode = "NETWORK_NOT_FOUND";
+  get message() {
+    return `Network "${this.name}" not found`;
+  }
+};
+var DefaultNetworkError = class extends Data3.TaggedError(
+  "DefaultNetworkError"
+) {
+  exitCode = 2;
+  errorCode = "DEFAULT_NETWORK";
+  get message() {
+    return `Cannot remove "${this.name}" because it is the default network. Use \`fast network set-default\` first.`;
+  }
+};
+var NoDefaultNetworkError = class extends Data3.TaggedError(
+  "NoDefaultNetworkError"
+) {
+  exitCode = 2;
+  errorCode = "NO_DEFAULT_NETWORK";
+  get message() {
+    return "No default network set. Use `fast network set-default <name>` to set one.";
+  }
+};
+var ReservedNameError = class extends Data3.TaggedError("ReservedNameError") {
+  exitCode = 2;
+  errorCode = "RESERVED_NAME";
+  get message() {
+    return `"${this.name}" is a reserved name and cannot be modified`;
+  }
+};
+var InvalidNetworkConfigError = class extends Data3.TaggedError(
+  "InvalidNetworkConfigError"
+) {
+  exitCode = 2;
+  errorCode = "INVALID_NETWORK_CONFIG";
+  get message() {
+    return `Invalid network config for "${this.name}"`;
+  }
+};
+var UnsupportedChainError = class extends Data3.TaggedError(
+  "UnsupportedChainError"
+) {
+  exitCode = 2;
+  errorCode = "UNSUPPORTED_CHAIN";
+  get message() {
+    return `Unsupported chain "${this.chain}". Run \`fast info bridge-chains\` to list supported chains.`;
+  }
+};
+
+// src/errors/payment.ts
+import { Data as Data4 } from "effect";
+var PaymentRejectedError = class extends Data4.TaggedError(
+  "PaymentRejectedError"
+) {
+  exitCode = 6;
+  errorCode = "PAYMENT_REJECTED";
+};
+var PaymentFailedError = class extends Data4.TaggedError(
+  "PaymentFailedError"
+) {
+  exitCode = 1;
+  errorCode = "PAYMENT_FAILED";
+};
+var InvalidPaymentLinkError = class extends Data4.TaggedError(
+  "InvalidPaymentLinkError"
+) {
+  exitCode = 2;
+  errorCode = "INVALID_PAYMENT_LINK";
+};
+var InsufficientPaymentBalanceError = class extends Data4.TaggedError(
+  "InsufficientPaymentBalanceError"
+) {
+  exitCode = 4;
+  errorCode = "INSUFFICIENT_PAYMENT_BALANCE";
+};
+
+// src/errors/transaction.ts
+import { Data as Data5 } from "effect";
+var TxNotFoundError = class extends Data5.TaggedError("TxNotFoundError") {
+  exitCode = 1;
+  errorCode = "TX_NOT_FOUND";
+  get message() {
+    return `Transaction not found: ${this.hash}`;
+  }
+};
+var TransactionFailedError = class extends Data5.TaggedError(
+  "TransactionFailedError"
+) {
+  exitCode = 2;
+  errorCode = "TX_FAILED";
+};
+var InvalidAddressError = class extends Data5.TaggedError(
+  "InvalidAddressError"
+) {
+  exitCode = 2;
+  errorCode = "INVALID_ADDRESS";
+};
+var InvalidAmountError = class extends Data5.TaggedError("InvalidAmountError") {
+  exitCode = 2;
+  errorCode = "INVALID_AMOUNT";
+};
+var InsufficientBalanceError = class extends Data5.TaggedError(
+  "InsufficientBalanceError"
+) {
+  exitCode = 2;
+  errorCode = "INSUFFICIENT_BALANCE";
+};
+var InsufficientGasError = class extends Data5.TaggedError(
+  "InsufficientGasError"
+) {
+  exitCode = 2;
+  errorCode = "INSUFFICIENT_GAS";
+};
+var TokenNotFoundError = class extends Data5.TaggedError("TokenNotFoundError") {
+  exitCode = 2;
+  errorCode = "TOKEN_NOT_FOUND";
+  get message() {
+    return `Unknown token "${this.token}". Run \`fast info bridge-tokens\` to list supported tokens.`;
+  }
+};
+var FundingRequiredError = class extends Data5.TaggedError(
+  "FundingRequiredError"
+) {
+  exitCode = 4;
+  errorCode = "FUNDING_REQUIRED";
+};
+
+// src/errors/usage.ts
+import { Data as Data6 } from "effect";
+var InvalidUsageError = class extends Data6.TaggedError("InvalidUsageError") {
+  exitCode = 2;
+  errorCode = "INVALID_USAGE";
+};
+var NotImplementedError = class extends Data6.TaggedError(
+  "NotImplementedError"
+) {
+  exitCode = 2;
+  errorCode = "NOT_IMPLEMENTED";
+};
+var UserCancelledError = class extends Data6.TaggedError("UserCancelledError") {
+  exitCode = 2;
+  errorCode = "USER_CANCELLED";
+  get message() {
+    return "Operation cancelled by user";
+  }
+};
+
+// src/services/storage/database.ts
+var FAST_DIR = join(homedir(), ".fast");
+var DB_PATH = join(FAST_DIR, "fast.db");
+var DatabaseService = class extends Context.Tag("Database")() {
+};
+var DatabaseLive = Layer.sync(DatabaseService, () => {
+  mkdirSync(FAST_DIR, { recursive: true, mode: 448 });
+  try {
+    chmodSync(FAST_DIR, 448);
+  } catch {
+  }
+  const sqlite = new Database(DB_PATH);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  const db = drizzle(sqlite, { schema: schema_exports });
+  const __dir = dirname(fileURLToPath(import.meta.url));
+  const migrationsFolder = [join(__dir, "../../../drizzle"), join(__dir, "../drizzle")].find(
+    (p) => existsSync(join(p, "meta/_journal.json"))
+  );
+  if (!migrationsFolder) {
+    throw new Error("Could not locate Drizzle migrations folder");
+  }
+  migrate(db, { migrationsFolder });
+  db.insert(metadata).values({ key: "default_network", value: "mainnet" }).onConflictDoNothing().run();
+  return {
+    query: (fn, message) => Effect.try({
+      try: () => fn(db),
+      catch: (cause) => new DatabaseError({ message, cause })
+    })
+  };
+});
+
+export {
+  AccountExistsError,
+  AccountNotFoundError,
+  NoDefaultAccountError,
+  DefaultAccountError,
+  PasswordRequiredError,
+  WrongPasswordError,
+  DatabaseError,
+  FileIOError,
+  InternalError,
+  FastSdkError,
+  NetworkExistsError,
+  NetworkNotFoundError,
+  DefaultNetworkError,
+  NoDefaultNetworkError,
+  ReservedNameError,
+  InvalidNetworkConfigError,
+  UnsupportedChainError,
+  PaymentRejectedError,
+  PaymentFailedError,
+  InvalidPaymentLinkError,
+  TxNotFoundError,
+  TransactionFailedError,
+  InvalidAddressError,
+  InvalidAmountError,
+  TokenNotFoundError,
+  FundingRequiredError,
+  InvalidUsageError,
+  UserCancelledError,
+  accounts,
+  history,
+  customNetworks,
+  metadata,
+  DatabaseService,
+  DatabaseLive
+};