mobilestacks 0.1.0

package/dist/src/types/config.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+export declare const NetworkConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    name: z.ZodString;
+    explorerUrl: z.ZodOptional<z.ZodString>;
+    faucetUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    name: string;
+    explorerUrl?: string | undefined;
+    faucetUrl?: string | null | undefined;
+}, {
+    url: string;
+    name: string;
+    explorerUrl?: string | undefined;
+    faucetUrl?: string | null | undefined;
+}>;
+export declare const WalletConfigSchema: z.ZodEffects<z.ZodObject<{
+    privateKey: z.ZodOptional<z.ZodString>;
+    seedPhrase: z.ZodOptional<z.ZodString>;
+    derivationPath: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    privateKey?: string | undefined;
+    seedPhrase?: string | undefined;
+    derivationPath?: string | undefined;
+    address?: string | undefined;
+}, {
+    privateKey?: string | undefined;
+    seedPhrase?: string | undefined;
+    derivationPath?: string | undefined;
+    address?: string | undefined;
+}>, {
+    privateKey?: string | undefined;
+    seedPhrase?: string | undefined;
+    derivationPath?: string | undefined;
+    address?: string | undefined;
+}, {
+    privateKey?: string | undefined;
+    seedPhrase?: string | undefined;
+    derivationPath?: string | undefined;
+    address?: string | undefined;
+}>;
+export declare const MobilestacksConfigSchema: z.ZodObject<{
+    networks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        name: z.ZodString;
+        explorerUrl: z.ZodOptional<z.ZodString>;
+        faucetUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        name: string;
+        explorerUrl?: string | undefined;
+        faucetUrl?: string | null | undefined;
+    }, {
+        url: string;
+        name: string;
+        explorerUrl?: string | undefined;
+        faucetUrl?: string | null | undefined;
+    }>>;
+    defaultNetwork: z.ZodString;
+    wallet: z.ZodEffects<z.ZodObject<{
+        privateKey: z.ZodOptional<z.ZodString>;
+        seedPhrase: z.ZodOptional<z.ZodString>;
+        derivationPath: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    }, {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    }>, {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    }, {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    networks: Record<string, {
+        url: string;
+        name: string;
+        explorerUrl?: string | undefined;
+        faucetUrl?: string | null | undefined;
+    }>;
+    defaultNetwork: string;
+    wallet: {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    };
+}, {
+    networks: Record<string, {
+        url: string;
+        name: string;
+        explorerUrl?: string | undefined;
+        faucetUrl?: string | null | undefined;
+    }>;
+    defaultNetwork: string;
+    wallet: {
+        privateKey?: string | undefined;
+        seedPhrase?: string | undefined;
+        derivationPath?: string | undefined;
+        address?: string | undefined;
+    };
+}>;
+export type NetworkConfig = z.infer<typeof NetworkConfigSchema>;
+export type WalletConfig = z.infer<typeof WalletConfigSchema>;
+export type MobilestacksConfig = z.infer<typeof MobilestacksConfigSchema>;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;EAQ9B,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/src/types/config.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const NetworkConfigSchema = z.object({
+    url: z.string().url(),
+    name: z.string(),
+    explorerUrl: z.string().url().optional(),
+    faucetUrl: z.string().url().nullable().optional(),
+});
+// Wallet config: allow privateKey, seedPhrase, or both. If both, privateKey is used.
+export const WalletConfigSchema = z.object({
+    privateKey: z.string().min(1, "Private key is required").optional(),
+    seedPhrase: z.string().optional(),
+    derivationPath: z.string().optional(),
+    address: z.string().optional(),
+}).refine((data) => data.privateKey || data.seedPhrase, { message: "Either privateKey or seedPhrase is required" });
+export const MobilestacksConfigSchema = z.object({
+    networks: z.record(NetworkConfigSchema),
+    defaultNetwork: z.string(),
+    wallet: WalletConfigSchema,
+});

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "mobilestacks",
+  "version": "0.1.0",
+  "description": "Professional Task Runner & CLI for the Stacks Blockchain",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mobilestacks": "dist/cli/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist/",
+    "src/",
+    "contracts/",
+    "Clarinet.toml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node ./dist/cli/index.js",
+    "build": "tsc",
+    "lint": "eslint src mobilestacks.config.ts --ext .ts",
+    "test": "vitest run",
+    "setup:simnet": "node scripts/setup-simnet.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "stacks",
+    "blockchain",
+    "clarity",
+    "smart-contracts",
+    "cli",
+    "task-runner",
+    "web3",
+    "bitcoin"
+  ],
+  "author": "mobilestacks",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mobilestacks/mobilestacks.git"
+  },
+  "homepage": "https://github.com/mobilestacks/mobilestacks#readme",
+  "bugs": {
+    "url": "https://github.com/mobilestacks/mobilestacks/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@hirosystems/clarinet-sdk": "^3.8.1",
+    "@types/inquirer": "^8.2.6",
+    "@typescript-eslint/eslint-plugin": "^6.20.0",
+    "@typescript-eslint/parser": "^6.20.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@stacks/network": "latest",
+    "@stacks/transactions": "latest",
+    "@stacks/wallet-sdk": "latest",
+    "commander": "^11.0.0",
+    "node-fetch": "^3.3.2",
+    "ts-node": "^10.9.1",
+    "zod": "^3.25.76"
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { loadConfig } from '../config/config-loading';
+import { RuntimeEnvironment } from '../core/runtime-environment';
+import { TaskDefinitions } from '../core/tasks-definitions';
+import { runInit } from './init';
+import inquirer from 'inquirer';
+
+// Import all user tasks
+import fs from 'fs';
+import path from 'path';
+// Auto-load all tasks in src/tasks
+const tasksDir = path.join(__dirname, '../tasks');
+fs.readdirSync(tasksDir)
+  .filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+  .forEach(f => {
+    require(path.join(tasksDir, f));
+  });
+
+const program = new Command();
+program
+  .name('mobilestacks')
+  .description('Professional Task Runner for Stacks')
+  .version('0.1.0');
+
+
+// Init command for project scaffolding
+program
+  .command('init')
+  .description('Scaffold a new mobilestacks project and config')
+  .action(async () => {
+    await runInit();
+    process.exit(0);
+  });
+
+// List all tasks if no command is given
+program.action(() => {
+  console.log(chalk.bold.blue('\nMobilestacks - Professional Task Runner for Stacks\n'));
+  console.log(chalk.white('USAGE: ') + chalk.green('mobilestacks <task> [options]\n'));
+  console.log(chalk.bold('Available tasks:'));
+  TaskDefinitions.getInstance().getAllTasks().forEach(task => {
+    const params = task.params.map(p => chalk.yellow(`--${p.name}`)).join(' ');
+    console.log('  ' + chalk.cyan(task.name) + ' ' + params);
+    console.log('    ' + chalk.gray(task.description));
+  });
+  console.log('\n' + chalk.white('Use ') + chalk.green('mobilestacks <task> --help') + chalk.white(' for more info on a task.'));
+  console.log(chalk.white('\nExample:'));
+  console.log('  ' + chalk.green('mobilestacks deploy-contract --contractName my-contract --file ./contracts/my-contract.clar --network testnet'));
+  console.log(chalk.white('\nDocs: ') + chalk.underline('https://github.com/your-org/mobilestacks#readme'));
+  program.help({ error: false });
+});
+
+// Dynamically add all registered tasks
+
+TaskDefinitions.getInstance().getAllTasks().forEach(task => {
+  const cmd = program.command(task.name)
+    .description(task.description);
+  task.params.forEach(param => {
+    const optStr = `--${param.name} <value>`;
+    if (param.required !== false) {
+      cmd.option(optStr, param.description);
+    } else {
+      cmd.option(optStr, param.description, param.defaultValue as string | boolean | undefined);
+    }
+  });
+  cmd.action(async (opts) => {
+    try {
+      // Prompt for missing required params
+      const missing = task.params.filter(p => p.required !== false && !opts[p.name]);
+      if (missing.length > 0) {
+        const answers = await inquirer.prompt(missing.map(p => ({
+          type: p.type === 'boolean' ? 'confirm' : 'input',
+          name: p.name,
+          message: p.description,
+          default: p.defaultValue
+        })));
+        Object.assign(opts, answers);
+      }
+      // Type conversion
+      task.params.forEach(p => {
+        if (opts[p.name] && p.type === 'number') opts[p.name] = Number(opts[p.name]);
+        if (opts[p.name] && p.type === 'boolean') opts[p.name] = Boolean(opts[p.name]);
+      });
+      const config = loadConfig();
+      const env = new RuntimeEnvironment(config);
+      const result = await task.action(opts, env);
+      if (typeof result === 'object') {
+        console.log(chalk.greenBright('Success!'));
+        console.dir(result, { depth: null, colors: true });
+      } else {
+        console.log(chalk.greenBright(result));
+      }
+    } catch (err) {
+      const error = err as Error;
+      console.error(chalk.redBright('Task failed:'), error.message || error);
+      if (error && typeof error === 'object' && 'stack' in error && error.stack) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+});
+
+program.parse(process.argv);

package/src/cli/init.ts

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+
+export async function runInit() {
+  console.log('Welcome to mobilestacks project initialization!');
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: path.basename(process.cwd()),
+    },
+    {
+      type: 'input',
+      name: 'mainnetUrl',
+      message: 'Stacks mainnet node URL:',
+      default: 'https://stacks-node-api.mainnet.stacks.co',
+    },
+    {
+      type: 'input',
+      name: 'testnetUrl',
+      message: 'Stacks testnet node URL:',
+      default: 'https://stacks-node-api.testnet.stacks.co',
+    },
+    {
+      type: 'input',
+      name: 'privateKey',
+      message: 'Your wallet private key (leave blank to use seed phrase):',
+    },
+    {
+      type: 'input',
+      name: 'seedPhrase',
+      message: 'Your wallet seed phrase (leave blank if using private key):',
+    },
+    {
+      type: 'input',
+      name: 'derivationPath',
+      message: 'Derivation path (default: m/44\'/5757\'/0\'/0/0):',
+      default: "m/44'/5757'/0'/0/0",
+    },
+  ]);
+
+  const config = `export default {\n  networks: {\n    mainnet: { url: '${answers.mainnetUrl}', name: 'mainnet' },\n    testnet: { url: '${answers.testnetUrl}', name: 'testnet' }\n  },\n  defaultNetwork: 'testnet',\n  wallet: {\n    ${answers.privateKey ? `privateKey: '${answers.privateKey}',` : ''}\n    ${answers.seedPhrase ? `seedPhrase: '${answers.seedPhrase}',` : ''}\n    derivationPath: '${answers.derivationPath}'\n  }\n};\n`;
+
+  fs.writeFileSync(path.join(process.cwd(), 'mobilestacks.config.ts'), config);
+  // Scaffold example contract
+  const contractsDir = path.join(process.cwd(), 'contracts');
+  if (!fs.existsSync(contractsDir)) fs.mkdirSync(contractsDir);
+  fs.writeFileSync(path.join(contractsDir, 'sample-contract.clar'), '(define-public (hello-world)\n  (ok "Hello, Stacks!"))\n');
+  // Scaffold example user task
+  const tasksDir = path.join(process.cwd(), 'src', 'tasks');
+  if (!fs.existsSync(tasksDir)) fs.mkdirSync(tasksDir, { recursive: true });
+  fs.writeFileSync(path.join(tasksDir, 'example-task.ts'),
+    "import { task } from '../core/dsl';\n\ntask('example', 'An example user task for onboarding')\n  .addParam('name', 'Your name', { type: 'string', required: false, defaultValue: 'World' })\n  .setAction(async (args) => {\n    return `Hello, ${args.name}! Welcome to mobilestacks.`;\n  });\n");
+  console.log('Created mobilestacks.config.ts, contracts/sample-contract.clar, and src/tasks/example-task.ts!');
+}

package/src/config/config-loading.ts

@@ -0,0 +1,31 @@
+import { MobilestacksConfigSchema, MobilestacksConfig } from '../types/config';
+import path from 'path';
+import fs from 'fs';
+import { env } from '../core/env';
+
+export function loadConfig(configPath?: string, cliOverrides: Record<string, unknown> = {}): MobilestacksConfig {
+  const configFile = configPath || path.resolve(process.cwd(), 'mobilestacks.config.ts');
+  if (!fs.existsSync(configFile)) {
+    throw new Error(`Config file not found: ${configFile}`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+  require('ts-node').register();
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+  const userConfig = require(configFile);
+  let config = userConfig.default || userConfig;
+
+  // .env override
+  if (env.privateKey) config.wallet.privateKey = env.privateKey;
+  if (env.mainnetUrl) config.networks.mainnet.url = env.mainnetUrl;
+  if (env.testnetUrl) config.networks.testnet.url = env.testnetUrl;
+
+  // CLI overrides
+  config = { ...config, ...cliOverrides };
+
+  const parsed = MobilestacksConfigSchema.safeParse(config);
+  if (!parsed.success) {
+    throw new Error('Invalid mobilestacks.config.ts: ' + JSON.stringify(parsed.error.format(), null, 2));
+  }
+  return parsed.data;
+}

package/src/core/dsl.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { task } from './dsl';
+import { TaskDefinitions } from './tasks-definitions';
+import { z } from 'zod';
+import { RuntimeEnvironment } from './runtime-environment';
+import { extendEnvironment, Extender } from './extender';
+
+describe('DSL', () => {
+  beforeEach(() => {
+    // Clear tasks before each test
+    (TaskDefinitions.getInstance() as unknown as { _tasks: unknown[] })._tasks = [];
+  });
+
+  it('should register a task with generic parameters', () => {
+    task('test-task', 'A test task')
+      .addParam('p1', 'param 1')
+      .setAction(async () => { return 'done'; });
+
+    const def = TaskDefinitions.getInstance().getTask('test-task');
+    expect(def).toBeDefined();
+    expect(def?.name).toBe('test-task');
+    expect(def?.params.length).toBe(1);
+  });
+
+  it('should validate Zod schema', async () => {
+    task('zod-task', 'Task with validation')
+      .addParam('age', 'Age param', { schema: z.number().min(18) })
+      .setAction(async (args) => {
+        return args.age;
+      });
+    
+    const def = TaskDefinitions.getInstance().getTask('zod-task');
+    expect(def).toBeDefined();
+
+    // Mock environment
+    const env = {} as RuntimeEnvironment;
+
+    // Valid call
+    const result = await def?.action({ age: 20 }, env);
+    expect(result).toBe(20);
+
+    // Invalid call
+    await expect(def?.action({ age: 10 }, env)).rejects.toThrow('Invalid value for parameter \'age\'');
+  });
+
+  it('should support environment extensions', () => {
+    
+    
+    // Clear extensions
+    (Extender.getInstance() as unknown as { _extensions: unknown[] })._extensions = [];
+
+    extendEnvironment((env: RuntimeEnvironment) => {
+      env['foo'] = 'bar';
+    });
+
+    const extensions = Extender.getInstance().getExtensions();
+    expect(extensions.length).toBe(1);
+    
+    const mockEnv = {} as RuntimeEnvironment;
+    extensions[0](mockEnv);
+    expect(mockEnv['foo']).toBe('bar');
+  });
+});

package/src/core/dsl.ts

@@ -0,0 +1,73 @@
+import { TaskDefinitions, TaskDefinition, TaskParam, TaskParamType } from './tasks-definitions';
+import { ZodSchema } from 'zod';
+import { RuntimeEnvironment } from './runtime-environment';
+import { extendEnvironment } from './extender';
+
+function task(name: string, description: string) {
+  const params: TaskParam[] = [];
+  return {
+    addParam(
+      paramName: string,
+      paramDesc: string,
+      options?: { type?: TaskParamType; required?: boolean; defaultValue?: unknown; schema?: ZodSchema }
+    ) {
+      params.push({
+        name: paramName,
+        description: paramDesc,
+        type: options?.type || 'string',
+        required: options?.required !== false, // default true
+        defaultValue: options?.defaultValue,
+        schema: options?.schema,
+      });
+      return this;
+    },
+    setAction(action: (args: Record<string, unknown>, env: RuntimeEnvironment) => Promise<unknown>) {
+      const def: TaskDefinition = {
+        name,
+        description,
+        params,
+        action: async (args: Record<string, unknown>, env: RuntimeEnvironment) => {
+          // Validate args against schemas if present
+          for (const param of params) {
+            if (param.schema && args[param.name] !== undefined) {
+              try {
+                param.schema.parse(args[param.name]);
+              } catch (error) {
+                throw new Error(`Invalid value for parameter '${param.name}': ${error}`);
+              }
+            }
+          }
+          return action(args, env);
+        },
+      };
+      TaskDefinitions.getInstance().addTask(def);
+      return def;
+    },
+  };
+}
+
+function subtask(name: string, description: string, parentTaskName?: string) {
+  // Register as a subtask with a parent if provided
+  const sub = task(name, description);
+  if (parentTaskName) {
+    // Attach parent info for future use (e.g., dependency graph, CLI grouping)
+    const def = TaskDefinitions.getInstance().getTask(name);
+    if (def) (def as TaskDefinition & { parent?: string }).parent = parentTaskName;
+  }
+  return sub;
+}
+
+// Workflow system: define and run ordered task/subtask sequences
+export type WorkflowStep = { taskName: string; args?: Record<string, unknown> };
+export type Workflow = WorkflowStep[];
+
+export async function runWorkflow(workflow: Workflow, env: RuntimeEnvironment) {
+  for (const step of workflow) {
+    const def = TaskDefinitions.getInstance().getTask(step.taskName);
+    if (!def) throw new Error(`Task not found: ${step.taskName}`);
+    // eslint-disable-next-line no-await-in-loop
+    await def.action(step.args || {}, env);
+  }
+}
+
+export { task, subtask, extendEnvironment };

package/src/core/env.ts

@@ -0,0 +1,8 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+export const env = {
+  privateKey: process.env.STACKS_PRIVATE_KEY,
+  mainnetUrl: process.env.STACKS_MAINNET_URL,
+  testnetUrl: process.env.STACKS_TESTNET_URL,
+};

package/src/core/extender.ts

@@ -0,0 +1,29 @@
+import { RuntimeEnvironment } from './runtime-environment';
+
+export type ExtensionFunc = (env: RuntimeEnvironment) => void;
+
+export class Extender {
+  private static _instance: Extender;
+  private _extensions: ExtensionFunc[] = [];
+
+  private constructor() {}
+
+  public static getInstance(): Extender {
+    if (!Extender._instance) {
+      Extender._instance = new Extender();
+    }
+    return Extender._instance;
+  }
+
+  public addExtension(func: ExtensionFunc) {
+    this._extensions.push(func);
+  }
+
+  public getExtensions(): ExtensionFunc[] {
+    return this._extensions;
+  }
+}
+
+export function extendEnvironment(func: ExtensionFunc) {
+  Extender.getInstance().addExtension(func);
+}

package/src/core/runtime-environment.ts

@@ -0,0 +1,74 @@
+import { MobilestacksConfig, NetworkConfig } from '../types/config';
+import { getAddressFromPrivateKey } from '@stacks/transactions';
+import { generateWallet } from '@stacks/wallet-sdk';
+import { StacksNetwork, createNetwork } from '@stacks/network';
+import { Extender } from './extender';
+
+export class RuntimeEnvironment {
+  public config: MobilestacksConfig;
+  public network: StacksNetwork;
+  public wallet!: { privateKey: string; address: string; accountIndex?: number };
+  public stacks: Record<string, unknown>; // Extension point
+  [key: string]: unknown; // Allow extensions
+
+  constructor(config: MobilestacksConfig) {
+    this.config = config;
+    const networkName = config.defaultNetwork;
+    const networkConfig: NetworkConfig = config.networks[networkName];
+    if (!networkConfig) {
+      throw new Error(`Network config not found for: ${networkName}`);
+    }
+    
+    // Instantiate proper StacksNetwork
+    if (networkName === 'mainnet' || networkName === 'testnet') {
+      this.network = createNetwork({
+        network: networkName,
+        client: { baseUrl: networkConfig.url }
+      });
+    } else {
+      // Default to testnet structure for custom networks
+       this.network = createNetwork({
+        network: 'testnet',
+        client: { baseUrl: networkConfig.url }
+      });
+    }
+
+    // Wallet: support privateKey, seedPhrase+derivationPath, or both (prefer privateKey)
+    if (config.wallet.privateKey) {
+      // Derive address from privateKey
+      const address = getAddressFromPrivateKey(config.wallet.privateKey, networkName === 'mainnet' ? 'mainnet' : 'testnet');
+      this.wallet = {
+        privateKey: config.wallet.privateKey,
+        address,
+      };
+    } else if (config.wallet.seedPhrase) {
+      const path = config.wallet.derivationPath || "m/44'/5757'/0'/0/0"; // Stacks main path
+      // generateWallet requires a password param
+      generateWallet({ secretKey: config.wallet.seedPhrase, password: '' }).then(wallet => {
+        const index = parseInt(path.split('/').pop() || '0', 10);
+        const account = wallet.accounts[index] || wallet.accounts[0];
+        // Use getStxAddress to get the address
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { getStxAddress } = require('@stacks/wallet-sdk/dist/models/account');
+        // network.addressVersion has singleSig/multiSig lines. 
+        const address = getStxAddress(account, this.network.transactionVersion); 
+        
+        this.wallet = {
+          privateKey: account.stxPrivateKey,
+          address,
+          accountIndex: account.index,
+        };
+      }).catch(() => {
+        throw new Error('Failed to generate wallet from seed phrase');
+      });
+    } else {
+      throw new Error('No privateKey or seedPhrase provided in wallet config');
+    }
+    this.stacks = {};
+
+    // Apply extensions
+    for (const extension of Extender.getInstance().getExtensions()) {
+      extension(this);
+    }
+  }
+}