@asentum/sdk 0.1.0 → 0.2.0

package/src/client.ts

@@ -1,272 +0,0 @@
-// Copyright 2026 The AsentumChain Contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * AsentumClient — read-only interface to an Asentum node's RPC.
- *
- * Wraps the node's HTTP endpoints in a typed, Promise-based API.
- * No private keys, no signing — just reads. For sending transactions,
- * use {@link AsentumWallet} which extends the client with a keypair.
- *
- * Works in Node.js (20+) and browsers — only depends on `fetch`.
- */
-
-export interface ChainInfo {
-  chainId: string;
-  height: number;
-  mempoolSize: number;
-  latestHeader: BlockHeader;
-}
-
-export interface BlockHeader {
-  parentHash: string;
-  stateRoot: string;
-  transactionsRoot: string;
-  receiptsRoot: string;
-  number: string;
-  timestamp: string;
-  gasLimit: string;
-  gasUsed: string;
-  baseFeePerGas: string;
-  proposer: string;
-}
-
-export interface Block {
-  header: BlockHeader;
-  hash?: string;
-  transactions: Transaction[];
-  receipts: Receipt[];
-}
-
-export interface Transaction {
-  kind: 'transfer' | 'deploy' | 'call';
-  body: {
-    chainId: string;
-    nonce: string;
-    maxPriorityFeePerGas: string;
-    maxFeePerGas: string;
-    gasLimit: string;
-    to: string;
-    value: string;
-    dataSize: number;
-  };
-  call?: {
-    method: string;
-    args: unknown[];
-  };
-}
-
-export interface Receipt {
-  txHash: string;
-  blockNumber: string;
-  txIndex: number;
-  sender: string;
-  recipient: string;
-  kind: string;
-  success: boolean;
-  gasUsed: string;
-  events: Array<{ name: string; data: unknown }>;
-  returnValue?: unknown;
-}
-
-export interface Balance {
-  address: string;
-  balance: string;
-  nonce: string;
-}
-
-export interface ValidatorInfo {
-  address: string;
-  stake: string;
-  bondedAt: string;
-  pubKeySize: number;
-}
-
-export interface ViewCallResult {
-  ok: boolean;
-  reason?: string;
-  returnValue?: unknown;
-  gasUsed?: string;
-  events?: Array<{ name: string; data: unknown }>;
-}
-
-export interface TxResult {
-  accepted: boolean;
-  reason?: string;
-  txHash?: string;
-}
-
-export interface Metadata {
-  chainId: string;
-  chainName: string;
-  chainIdDecimal: string;
-  currentBlock: string;
-  nativeCurrency: { name: string; symbol: string; decimals: number };
-  rpcUrls: string[];
-  blockExplorerUrls: string[];
-  faucetUrl: string;
-}
-
-export class AsentumClient {
-  readonly rpcUrl: string;
-
-  constructor(rpcUrl: string) {
-    this.rpcUrl = rpcUrl.replace(/\/$/, '');
-  }
-
-  // ---------------------------------------------------------------------------
-  // Chain reads
-  // ---------------------------------------------------------------------------
-
-  /** Get chain info including the latest block header. */
-  async getChainInfo(): Promise<ChainInfo> {
-    const raw = await this.get<ChainInfo & { height: string }>('/chain');
-    return { ...raw, height: Number(BigInt(raw.height)) };
-  }
-
-  /** Get the current block height. */
-  async getBlockNumber(): Promise<number> {
-    const info = await this.getChainInfo();
-    return info.height;
-  }
-
-  /** Get the chain ID as a bigint. */
-  async getChainId(): Promise<bigint> {
-    const info = await this.getChainInfo();
-    return BigInt(info.chainId);
-  }
-
-  /** Get a block by number, including transactions and receipts. */
-  async getBlock(number: number | bigint): Promise<Block | null> {
-    try {
-      return await this.get<Block>(`/block/${number}`);
-    } catch {
-      return null;
-    }
-  }
-
-  /** Get the balance and nonce for an address. */
-  async getBalance(address: string): Promise<Balance> {
-    return this.get<Balance>(`/balance/${address}`);
-  }
-
-  /** Get the nonce for an address (shorthand for getBalance().nonce). */
-  async getNonce(address: string): Promise<bigint> {
-    const bal = await this.getBalance(address);
-    return BigInt(bal.nonce);
-  }
-
-  /** Get the receipt for a transaction by hash. */
-  async getReceipt(txHash: string): Promise<Receipt | null> {
-    try {
-      const r = await this.get<Receipt | { error: string; txHash: string }>(`/receipts/${txHash}`);
-      // The chain returns 200 OK with { error: "receipt not found", txHash }
-      // when a tx isn't yet mined. Treat that as "not found" so callers
-      // (notably tx.wait's polling loop) can keep waiting.
-      if (r && typeof r === 'object' && 'error' in r) return null;
-      return r as Receipt;
-    } catch {
-      return null;
-    }
-  }
-
-  /** Get the source code of a deployed contract (hex-encoded). */
-  async getCode(address: string): Promise<string> {
-    const res = await this.jsonRpc<string>('eth_getCode', [address, 'latest']);
-    return res;
-  }
-
-  /** Get the source code of a deployed contract as a UTF-8 string. */
-  async getContractSource(address: string): Promise<string | null> {
-    const hex = await this.getCode(address);
-    if (!hex || hex === '0x' || hex.length <= 2) return null;
-    const raw = hex.startsWith('0x') ? hex.slice(2) : hex;
-    const bytes = new Uint8Array(raw.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(raw.substr(i * 2, 2), 16);
-    }
-    return new TextDecoder().decode(bytes);
-  }
-
-  /** Call a contract view function (read-only, no transaction). */
-  async viewCall(contract: string, method: string, args: unknown[] = []): Promise<ViewCallResult> {
-    return this.post<ViewCallResult>('/view', { contract, method, args });
-  }
-
-  /** Get the current active validator set. */
-  async getValidators(): Promise<{ count: number; validators: ValidatorInfo[] }> {
-    return this.get('/validators');
-  }
-
-  /** Get the chain metadata (EIP-3085 shape). */
-  async getMetadata(): Promise<Metadata> {
-    return this.get<Metadata>('/metadata');
-  }
-
-  /** Health check. */
-  async isHealthy(): Promise<boolean> {
-    try {
-      const res = await this.get<{ status: string }>('/health');
-      return res.status === 'ok';
-    } catch {
-      return false;
-    }
-  }
-
-  /** Readiness check (chain advancing). */
-  async isReady(): Promise<boolean> {
-    try {
-      await fetch(`${this.rpcUrl}/ready`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /** Request test ASE from the faucet. */
-  async faucet(to: string, amount: string = '100000000000000000000'): Promise<TxResult> {
-    return this.post<TxResult>('/dev/faucet', { to, amount });
-  }
-
-  /** Submit a raw signed transaction (hex-encoded SSZ bytes). */
-  async submitRawTx(rawTxHex: string): Promise<TxResult> {
-    return this.post<TxResult>('/tx', { rawTx: rawTxHex });
-  }
-
-  // ---------------------------------------------------------------------------
-  // Ethereum JSON-RPC (subset)
-  // ---------------------------------------------------------------------------
-
-  /** Send a raw JSON-RPC request. */
-  async jsonRpc<T>(method: string, params: unknown[] = []): Promise<T> {
-    const res = await fetch(`${this.rpcUrl}/`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
-    });
-    if (!res.ok) throw new Error(`JSON-RPC ${method} failed: ${res.status}`);
-    const body = (await res.json()) as { result?: T; error?: { message: string } };
-    if (body.error) throw new Error(`JSON-RPC error: ${body.error.message}`);
-    return body.result as T;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Internal HTTP helpers
-  // ---------------------------------------------------------------------------
-
-  private async get<T>(path: string): Promise<T> {
-    const res = await fetch(`${this.rpcUrl}${path}`);
-    if (!res.ok) throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
-    return (await res.json()) as T;
-  }
-
-  private async post<T>(path: string, body: unknown): Promise<T> {
-    const res = await fetch(`${this.rpcUrl}${path}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
-    return (await res.json()) as T;
-  }
-}

package/src/contract.ts

@@ -1,138 +0,0 @@
-// Copyright 2026 The AsentumChain Contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * AsentumContract — a deployed contract instance that wraps view calls
- * and write transactions.
- *
- * Usage:
- *
- *   // Deploy via a wallet
- *   const contract = await wallet.deploy(source);
- *   console.log(contract.address);
- *
- *   // Or wrap an existing deployed contract
- *   const contract = new AsentumContract(client, '0xabc...');
- *
- *   // Read (free, no signature)
- *   const name = await contract.view('name');
- *   const balance = await contract.view('balanceOf', ['0x...']);
- *
- *   // Write (requires a wallet)
- *   const tx = await contract.send('transfer', ['0x...', '1000']);
- *   const receipt = await tx.wait();
- */
-
-import { AsentumClient, type Receipt, type ViewCallResult } from './client.js';
-import type { AsentumWallet, SentTx } from './wallet.js';
-
-export class AsentumContract {
-  readonly client: AsentumClient;
-  readonly address: string;
-  /** The deploy tx, if this contract was deployed in this session. */
-  readonly deployTx?: SentTx;
-  /** The wallet used to deploy this contract, if any. Used as default signer for send(). */
-  private wallet?: AsentumWallet;
-
-  constructor(
-    client: AsentumClient,
-    address: string,
-    deployTx?: SentTx,
-    wallet?: AsentumWallet,
-  ) {
-    this.client = client;
-    this.address = address;
-    this.deployTx = deployTx;
-    this.wallet = wallet;
-  }
-
-  /**
-   * Call a view function (read-only, free, no transaction).
-   *
-   * @param method - The function name to call.
-   * @param args   - Arguments to pass to the function.
-   * @returns The return value of the function.
-   */
-  async view(method: string, args: unknown[] = []): Promise<unknown> {
-    const result = await this.client.viewCall(this.address, method, args);
-    if (!result.ok) {
-      throw new Error(`view call ${method}() failed: ${result.reason || 'unknown'}`);
-    }
-    return result.returnValue;
-  }
-
-  /**
-   * Call a view function and return the full result including gas + events.
-   */
-  async viewFull(method: string, args: unknown[] = []): Promise<ViewCallResult> {
-    return this.client.viewCall(this.address, method, args);
-  }
-
-  /**
-   * Send a state-changing transaction to the contract.
-   *
-   * @param method  - The function name to call.
-   * @param args    - Arguments to pass.
-   * @param opts    - Optional: value to attach, gas limit, nonce, wallet override.
-   * @returns A SentTx with `.hash` and `.wait()`.
-   */
-  async send(
-    method: string,
-    args: unknown[] = [],
-    opts: {
-      value?: string | number | bigint;
-      gasLimit?: bigint;
-      nonce?: bigint;
-      wallet?: AsentumWallet;
-    } = {},
-  ): Promise<SentTx> {
-    const signer = opts.wallet ?? this.wallet;
-    if (!signer) {
-      throw new Error(
-        'no wallet available — pass a wallet in opts or create the contract via wallet.deploy()',
-      );
-    }
-    return signer.sendCall({
-      to: this.address,
-      method,
-      args,
-      value: opts.value,
-      gasLimit: opts.gasLimit,
-      nonce: opts.nonce,
-    });
-  }
-
-  /**
-   * Attach a wallet to this contract for future send() calls.
-   */
-  connect(wallet: AsentumWallet): AsentumContract {
-    return new AsentumContract(this.client, this.address, this.deployTx, wallet);
-  }
-
-  /**
-   * Get the source code of this contract as a UTF-8 string.
-   * Returns null if the address has no deployed code.
-   */
-  async getSource(): Promise<string | null> {
-    return this.client.getContractSource(this.address);
-  }
-
-  /**
-   * Get the ASE balance of this contract.
-   */
-  async getBalance(): Promise<bigint> {
-    const bal = await this.client.getBalance(this.address);
-    return BigInt(bal.balance);
-  }
-
-  /**
-   * Wait for the deploy transaction to be confirmed (if this contract
-   * was deployed in this session). Useful after `wallet.deploy()`.
-   */
-  async waitForDeploy(timeoutMs = 15_000): Promise<Receipt> {
-    if (!this.deployTx) {
-      throw new Error('this contract was not deployed in this session — no deploy tx to wait for');
-    }
-    return this.deployTx.wait(timeoutMs);
-  }
-}

package/src/index.ts

@@ -1,75 +0,0 @@
-// Copyright 2026 The AsentumChain Contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @asentum/sdk — TypeScript SDK for building on Asentum.
- *
- * Three main classes:
- *
- *   - {@link AsentumClient} — read-only interface to the chain
- *   - {@link AsentumWallet} — keypair + signing + submitting
- *   - {@link AsentumContract} — deployed contract interaction
- *
- * Quick start:
- *
- * ```ts
- * import { AsentumClient, AsentumWallet } from '@asentum/sdk';
- *
- * const client = new AsentumClient('https://testnet.asentum.com');
- * const wallet = AsentumWallet.create(client);
- *
- * // Fund the wallet from the testnet faucet
- * await wallet.requestFaucet();
- *
- * // Check balance
- * const balance = await wallet.getBalance();
- * console.log('balance:', balance, 'wei');
- *
- * // Deploy a contract
- * const contract = await wallet.deploy(`
- *   function init() { storage.set('msg', 'hello'); emit('Init', {}); }
- *   function getMessage() { return storage.get('msg'); }
- *   function setMessage(m) { storage.set('msg', m); emit('Set', { m }); }
- * `);
- * console.log('deployed at:', contract.address);
- *
- * // Initialize the contract
- * const initTx = await contract.send('init');
- * await initTx.wait();
- *
- * // Read from the contract (free, no tx)
- * const msg = await contract.view('getMessage');
- * console.log('message:', msg);  // "hello"
- *
- * // Write to the contract (sends a tx)
- * const setTx = await contract.send('setMessage', ['world']);
- * await setTx.wait();
- *
- * const msg2 = await contract.view('getMessage');
- * console.log('message:', msg2);  // "world"
- * ```
- */
-
-export { AsentumClient } from './client.js';
-export type {
-  Balance,
-  Block,
-  BlockHeader,
-  ChainInfo,
-  Metadata,
-  Receipt,
-  Transaction,
-  TxResult,
-  ValidatorInfo,
-  ViewCallResult,
-} from './client.js';
-
-export { AsentumWallet, parseAse, formatAse } from './wallet.js';
-export type {
-  DeployOpts,
-  SendCallOpts,
-  SendTransferOpts,
-  SentTx,
-} from './wallet.js';
-
-export { AsentumContract } from './contract.js';