TypeScript interfaces and types

interface NaiAsset {
  amount: string;      // Amount in satoshis (integer)
  precision: number;   // Decimal precision (3 for HIVE/HBD, 6 for VESTS)
  nai: string;         // Asset identifier (@@000000021 for HIVE)
}

// 100.000 HIVE
const hive: NaiAsset = {
  amount: "100000",
  precision: 3,
  nai: "@@000000021"
};

// 50.000 HBD
const hbd: NaiAsset = {
  amount: "50000",
  precision: 3,
  nai: "@@000000013"
};

// 1000.000000 VESTS
const vests: NaiAsset = {
  amount: "1000000000",
  precision: 6,
  nai: "@@000000037"
};

interface IHiveAssetData {
  amount: string;   // Amount with decimal point ("100.000")
  symbol: string;   // Asset symbol ("HIVE", "HBD", "VESTS")
}

type TNaiAssetConvertible = number | string | bigint;

type TNaiAssetSource = TNaiAssetConvertible | NaiAsset;

type TTimestamp = Date | number | string;

const timestamps: TTimestamp[] = [
  new Date(),
  Date.now(),
  "2025-03-04T12:00:00Z",
  "+30m"
];

type THexString = string;

type TPublicKey = string;

const pubKey: TPublicKey = "STM7Q2rLBqzPzFeteQZewv9Lu3NLE69fZoLeL6YK59t7UmssCBNTU";

type TSignature = string;

interface IPrivateKeyData {
  associatedPublicKey: string;  // Public key in WIF format
  wifPrivateKey: string;        // Private key in WIF format
}

interface IBrainKeyData extends IPrivateKeyData {
  brainKey: string;             // Brain key phrase
  wifPrivateKey: string;        // Derived private key
  associatedPublicKey: string;  // Derived public key
}

type TBlockHash = string;  // 20 byte string or hex string (40 characters)

const blockId: TBlockHash = "0000000000000000000000000000000000000000";

type TTransactionId = string;  // 20 byte string or hex string (40 characters)

type TAccountName = string;

interface authority {
  weight_threshold: number;                  // Minimum weight required
  account_auths: Record<string, number>;     // Account name → weight
  key_auths: Record<string, number>;         // Public key → weight
}

const auth: authority = {
  weight_threshold: 1,
  account_auths: {},
  key_auths: {
    "STM7Q2rLBqzPzFeteQZewv9Lu3NLE69fZoLeL6YK59t7UmssCBNTU": 1
  }
};

type TTransactionRequiredAuthorities = {
  posting: Set<string>;      // Accounts requiring posting authority
  active: Set<string>;       // Accounts requiring active authority
  owner: Set<string>;        // Accounts requiring owner authority
  other: Array<authority>;   // Custom authorities
};

interface IWaxOptions extends IWaxBaseExtendibleOptions {
  wasmLocation?: string;  // Path to WASM file
}

interface IWaxBaseExtendibleOptions {
  chainId: THexString;    // Chain ID in hex format
}

interface IWaxOptionsChain extends IWaxOptions, IWaxChainExtendibleOptions {}

interface IWaxChainExtendibleOptions extends IWaxBaseExtendibleOptions {
  apiEndpoint: string;        // JSON-RPC API endpoint
  restApiEndpoint: string;    // REST API endpoint
  waxApiCaller?: string;      // X-Wax-Api-Caller header value
  apiTimeout: number;         // Request timeout in milliseconds
}

interface IChainConfig {
  // Chain limits and constants
  HIVE_MIN_ACCOUNT_NAME_LENGTH: number;
  HIVE_MAX_ACCOUNT_NAME_LENGTH: number;
  HIVE_MAX_BLOCK_SIZE: number;
  // ... many more protocol constants
}

interface transaction {
  ref_block_num: number;         // Reference block number (TAPOS)
  ref_block_prefix: number;      // Reference block prefix (TAPOS)
  expiration: string;            // Expiration time (ISO 8601)
  operations: Array<operation>;  // Transaction operations
  extensions: Array<any>;        // Transaction extensions
  signatures: Array<string>;     // Transaction signatures
}

interface ApiTransaction {
  ref_block_num: number;
  ref_block_prefix: number;
  expiration: string;
  operations: Array<ApiOperation>;
  extensions: object[];
  signatures: string[];
}

interface ApiOperation {
  type: string;                  // Operation type name
  value: Record<string, any>;    // Operation parameters
}

type LegacyApiTransaction = {
  ref_block_num: number;
  ref_block_prefix: number;
  expiration: string;
  operations: Array<LegacyApiOperation>;
  extensions: object[];
  signatures: string[];
};

type LegacyApiOperation = 
  | [string, Record<string, any>]   // ["vote", {...}]
  | [number, Record<string, any>];  // [0, {...}]

interface IManabarData {
  current: bigint;   // Current manabar value
  max: bigint;       // Maximum manabar value
  percent: number;   // Percent loaded (0-100 with 2 decimal places)
}

const manabar: IManabarData = {
  current: BigInt("9500000000"),
  max: BigInt("10000000000"),
  percent: 95.00
};

enum EManabarType {
  UPVOTE = 0,
  DOWNVOTE = 1,
  RC = 2
}

interface IBinaryViewOutputData {
  binary: string;                    // Binary data in hex format
  offsets: IBinaryViewNode[];        // AST structure with offsets
}

type IBinaryViewNode = 
  | IBinaryViewScalarNode 
  | IBinaryViewArrayNode 
  | IBinaryViewObjectNode;

interface IBinaryViewBaseNode {
  key: string;      // Node key/name
  offset: number;   // Byte offset in binary
  size: number;     // Size in bytes
}

interface IBinaryViewScalarNode extends IBinaryViewBaseNode {
  type: "scalar";
  value: string;
}

interface IBinaryViewArrayNode extends IBinaryViewBaseNode {
  type: "array";
  length: number;
  children: IBinaryViewNode[];
  value: string;
}

interface IBinaryViewObjectNode extends IBinaryViewBaseNode {
  type: "object";
  children: IBinaryViewNode[];
  value?: string;
}

interface ISignatureProvider {
  signDigest(publicKey: TPublicKey, digest: THexString): string;
  // ... additional methods
}

interface IOnlineEncryptionProvider {
  encryptData(data: string, publicKey: TPublicKey): Promise<string>;
  // ... additional methods
}

enum EAssetName {
  HIVE = "HIVE",
  HBD = "HBD",
  VESTS = "VESTS"
}

enum ECommentFormat {
  HTML = "html",
  MARKDOWN = "markdown",
  MIXED = "markdown+html"
}

enum EChainApiType {
  JSONRPC = "jsonrpc",
  REST = "rest"
}

class WaxError extends Error {
  constructor(message: string);
}

try {
  // WAX operations
} catch (error) {
  if (error instanceof WaxError) {
    console.error('WAX error:', error.message);
  }
}

interface IOperationSink {
  api: IWaxBaseInterface;  // Access to WAX API instance
}

abstract class OperationBase {
  abstract finalize(sink: IOperationSink): Iterable<operation>;
}

function isPublicKey(key: string): boolean;

import { isPublicKey } from '@hiveio/wax';

const key = "STM7Q2rLBqzPzFeteQZewv9Lu3NLE69fZoLeL6YK59t7UmssCBNTU";
if (isPublicKey(key)) {
  console.log('Valid public key');
}

type TDeepWaxApiRequestPartial<T> = T extends object ? {
  [P in keyof T]?: TDeepWaxApiRequestPartial<T[P]>;
} & Omit<TWaxApiRequest<any, any>, 'params' | 'result'> : T;

type TWaxApiRequest<TReq, TRes> = {
  readonly params: TReq;
  readonly result: TRes;
  readonly responseArray?: boolean;
  readonly method?: string;
  readonly urlPath?: string;
};