quantumcoin 7.0.15 → 8.0.1

package/src/wallet/wallet.d.ts

@@ -9,6 +9,7 @@ export class SigningKey {
     constructor(privateKeyBytes: Uint8Array, publicKeyBytes: Uint8Array);
     privateKeyBytes: Uint8Array<ArrayBuffer>;
     publicKeyBytes: Uint8Array<ArrayBuffer>;
+    toJSON(): {};
 }
 /**
  * AbstractSigner base (minimal).
@@ -18,7 +19,7 @@ export class AbstractSigner {
      * @param {import("../providers/provider").AbstractProvider|null} provider
      */
     constructor(provider: import("../providers/provider").AbstractProvider | null);
-    provider: import("../providers/provider").AbstractProvider;
+    provider: import("../providers/provider").AbstractProvider | null;
     getAddress(): Promise<void>;
 }
 /**
@@ -40,6 +41,9 @@ export class BaseWallet extends AbstractSigner {
     address: string;
     readonly publicKey: string;
     readonly seed: string | null;
+    toJSON(): {
+        address: string;
+    };
     getAddress(): Promise<string>;
     /**
      * Sign a transaction using quantum-coin-js-sdk signRawTransaction().
@@ -47,6 +51,36 @@ export class BaseWallet extends AbstractSigner {
      * @returns {Promise<string>}
      */
     signTransaction(tx: import("../providers/provider").TransactionRequest): Promise<string>;
+    /**
+     * Sign an arbitrary message (EIP-191 personal-message scheme), synchronously.
+     * Returns an opaque post-quantum signature blob (0x hex) that embeds the
+     * signer's public key. Optional signingContext: when omitted/null the compact
+     * context is derived from the key type (0 for keyType 3, 1 for keyType 5);
+     * pass 2 for the full-signature scheme on a keyType 3 wallet.
+     * @param {string|Uint8Array} message
+     * @param {number|null=} signingContext
+     * @returns {string}
+     */
+    signMessageSync(message: string | Uint8Array, signingContext?: (number | null) | undefined): string;
+    /**
+     * Sign an arbitrary message (EIP-191). Async wrapper over signMessageSync.
+     * @param {string|Uint8Array} message
+     * @param {number|null=} signingContext
+     * @returns {Promise<string>}
+     */
+    signMessage(message: string | Uint8Array, signingContext?: (number | null) | undefined): Promise<string>;
+    /**
+     * Internal: sign a transaction and return both the raw serialized transaction
+     * and the signer-computed transaction hash. The hash is later used to
+     * verify that an untrusted RPC node broadcast exactly the transaction we
+     * signed rather than substituting a different one.
+     * @param {import("../providers/provider").TransactionRequest} tx
+     * @returns {Promise<{ raw: string, hash: string|null }>}
+     */
+    _signDetailed(tx: import("../providers/provider").TransactionRequest): Promise<{
+        raw: string;
+        hash: string | null;
+    }>;
     /**
      * Signs and sends a transaction.
      * @param {import("../providers/provider").TransactionRequest} tx
@@ -59,34 +93,21 @@ export class BaseWallet extends AbstractSigner {
  */
 export class Wallet extends BaseWallet {
     /**
-     * Returns the seed phrase (list of words) if this wallet has a seed, else null.
-     * Derived from the stored pre-expansion seed via seed-words.getWordListFromSeedArray.
-     */
-    getPhrase(): string[] | null;
-    /**
-     * Returns the recommended signing context for this wallet.
-     * Setting fullSign to true may incur additional gas cost.
-     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
-     * @returns {number}
-     */
-    getSigningContext(fullSign?: boolean | null): number;
-    /**
-     * Returns the key type of this wallet, derived from its public key length:
-     * 3 (KEY_TYPE_HYBRIDEDMLDSASLHDSA) or 5 (KEY_TYPE_HYBRIDEDMLDSASLHDSA5).
-     *
-     * The key type drives gas-price selection via `getFeeData`. Note that the
-     * underlying quantum-coin-js-sdk gas-price model supports only DynamicFeeTx
-     * (dynamic-fee transactions); legacy/other transaction fee types are not supported.
-     * @returns {number} 3 or 5.
+     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
+     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
+     * Desktop/Mobile/Web/CLI wallet applications.
+     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
+     * @returns {string}
      */
-    getKeyType(): number;
+    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
     /**
      * Creates a new random wallet.
      * @param {import("../providers/provider").AbstractProvider=} provider
      * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
      * @returns {Wallet}
      */
-    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined, keyType?: number | null): Wallet;
+    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined, keyType?: (number | null) | undefined): Wallet;
     /**
      * Creates a wallet from raw seed bytes.
      * @param {number[]} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
@@ -153,14 +174,36 @@ export class Wallet extends BaseWallet {
      */
     encryptSync(password: string | Uint8Array): string;
     /**
-     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
-     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
-     * Desktop/Mobile/Web/CLI wallet applications.
-     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
-     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
-     * @returns {string}
+     * Returns the seed phrase (list of words) if this wallet has a seed, else null.
+     * Derived from the stored pre-expansion seed via seed-words.getWordListFromSeedArray.
+     *
+     * Non-null for wallets created via createRandom, fromPhrase, fromSeed, and
+     * fromEncryptedJsonSync when the JSON is a version-5 keystore produced by
+     * encryptSync on a seed-bearing wallet or by encryptSeedSync.
+     * Null for fromKeys and for v3/v4 keystores without preExpansionSeed.
+     *
+     * @returns {string[]|null}
      */
-    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
+    getPhrase(): string[] | null;
+    /**
+     * Returns the recommended signing context for this wallet.
+     * Setting fullSign to true may incur additional gas cost.
+     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
+     * @returns {number}
+     */
+    getSigningContext(fullSign?: (boolean | null) | undefined): number;
+    /**
+     * Returns the key type of this wallet, derived from its public key length:
+     * 3 (KEY_TYPE_HYBRIDEDMLDSASLHDSA) or 5 (KEY_TYPE_HYBRIDEDMLDSASLHDSA5).
+     *
+     * The key type drives gas-price selection via `getFeeData`. Note that the
+     * underlying quantum-coin-js-sdk gas-price model supports only DynamicFeeTx
+     * (dynamic-fee transactions); legacy/other transaction fee types are not supported.
+     *
+     * @returns {number} 3 or 5.
+     * @throws if the public key length is unsupported.
+     */
+    getKeyType(): number;
     /**
      * Returns a new wallet connected to a provider.
      * @param {import("../providers/provider").AbstractProvider} provider
@@ -200,3 +243,16 @@ export class VoidSigner extends AbstractSigner {
     _address: string;
     getAddress(): Promise<string>;
 }
+/**
+ * Recover the signer's 32-byte address from an EIP-191 message signature.
+ *
+ * QuantumCoin has no ECDSA ecrecover; the post-quantum signature embeds the
+ * public key, which is extracted and verified against the message digest before
+ * the address is returned. Throws INVALID_ARGUMENT if the signature is malformed
+ * or does not verify. Synchronous, matching ethers' verifyMessage.
+ *
+ * @param {string|Uint8Array} message The original message (strings are UTF-8 encoded).
+ * @param {string|Uint8Array} signature The signature produced by signMessage.
+ * @returns {string} 0x-prefixed 32-byte signer address.
+ */
+export function verifyMessage(message: string | Uint8Array, signature: string | Uint8Array): string;

package/src/wallet/wallet.js

@@ -12,8 +12,9 @@ const qcsdk = require("quantum-coin-js-sdk");
 const seedWords = require("seed-words");
 const { JsonRpcProvider } = require("../providers/json-rpc-provider");
 const { assertArgument, assertSecretArgument, makeError } = require("../errors");
-const { arrayify, bytesToHex, hexToBytes, isHexString, normalizeHex } = require("../internal/hex");
-const { getAddress } = require("../utils/address");
+const { arrayify, bytesToHex, bytesToUtf8, hexToBytes, isHexString, normalizeHex, utf8ToBytes } = require("../internal/hex");
+const { computeAddress, getAddress } = require("../utils/address");
+const { hashMessage } = require("../utils/hashing");
 const { WeiPerEther } = require("../constants");
 
 function _requireInitialized() {
@@ -34,6 +35,13 @@ function _bytesToNumberArray(bytes) {
   return Array.from(bytes);
 }
 
+// Upper bound on the message size accepted by signMessage/signMessageSync. The
+// message is only ever hashed to a 32-byte digest, so there is no protocol need
+// for large inputs; this cap is a guardrail against accidentally signing an
+// unbounded buffer (e.g. a whole file passed in by mistake). 1 MiB is far larger
+// than any realistic personal_sign payload.
+const MAX_MESSAGE_BYTES = 1024 * 1024;
+
 /**
  * Verify that a private/public key pair is internally consistent (the public
  * key really corresponds to the private key). Constructing a wallet from a
@@ -214,6 +222,74 @@ class BaseWallet extends AbstractSigner {
     return raw;
   }
 
+  /**
+   * Sign an arbitrary message using QuantumCoin's EIP-191 personal-message
+   * scheme, synchronously.
+   *
+   * The message is hashed with {@link hashMessage} (the same
+   * `keccak256("\x19Ethereum Signed Message:\n" + len + message)` digest used by
+   * `personal_sign` in quantum-coin-go), producing a 32-byte digest that is then
+   * signed with the wallet's post-quantum key.
+   *
+   * Unlike Ethereum's 65-byte `(r, s, v)` signature, the returned value is an
+   * opaque, scheme-dependent multi-kilobyte blob whose first byte is the scheme
+   * id and which EMBEDS the signer's public key. This is what allows
+   * {@link verifyMessage} to recover the signer address without an ecrecover
+   * primitive.
+   *
+   * @param {string|Uint8Array} message The message to sign (strings are UTF-8 encoded).
+   *   Must be at most {@link MAX_MESSAGE_BYTES} (1 MiB) once UTF-8 encoded.
+   * @param {number|null=} signingContext Optional signing context. When omitted or
+   *   null, `quantum-coin-js-sdk` derives the compact context from the key type
+   *   (0 for keyType 3, 1 for keyType 5); pass 2 to request the full-signature
+   *   scheme for a keyType 3 wallet.
+   * @returns {string} 0x-prefixed signature blob (public key embedded).
+   * @throws {TypeError} INVALID_ARGUMENT if the message exceeds the size limit.
+   */
+  signMessageSync(message, signingContext) {
+    _requireInitialized();
+    const msgBytes = typeof message === "string" ? utf8ToBytes(message) : arrayify(message);
+    assertArgument(
+      msgBytes.length <= MAX_MESSAGE_BYTES,
+      `message too long (max ${MAX_MESSAGE_BYTES} bytes)`,
+      "message",
+      msgBytes.length,
+    );
+    const digestArr = _bytesToNumberArray(hexToBytes(hashMessage(msgBytes)));
+    const privArr = _bytesToNumberArray(this.signingKey.privateKeyBytes);
+    const pubArr = _bytesToNumberArray(this.signingKey.publicKeyBytes);
+    const ctx = signingContext == null ? null : signingContext;
+    const res = qcsdk.sign(privArr, digestArr, ctx);
+    if (!res || typeof res !== "object" || res.resultCode !== 0 || res.signature == null) {
+      throw makeError("signMessage failed", "UNKNOWN_ERROR", {
+        resultCode: res && typeof res === "object" ? res.resultCode : null,
+      });
+    }
+    // qcsdk.sign returns the signature-only bytes. Combine the public key into
+    // the blob (sig + pubKey) so the result is self-describing and verifyMessage
+    // can recover the signer without a separately supplied public key.
+    const sigArr = Array.from(res.signature);
+    const combined = qcsdk.combinePublicKeySignature(pubArr, sigArr);
+    if (typeof combined !== "string") {
+      throw makeError("signMessage failed to combine public key with signature", "UNKNOWN_ERROR", {});
+    }
+    return normalizeHex(combined);
+  }
+
+  /**
+   * Sign an arbitrary message (EIP-191). Async wrapper over
+   * {@link BaseWallet#signMessageSync} that honors the ethers `Signer` interface
+   * contract (`Signer.signMessage` is async); the underlying PQC signing is
+   * synchronous.
+   *
+   * @param {string|Uint8Array} message The message to sign (strings are UTF-8 encoded).
+   * @param {number|null=} signingContext Optional signing context (see signMessageSync).
+   * @returns {Promise<string>} 0x-prefixed signature blob (public key embedded).
+   */
+  async signMessage(message, signingContext) {
+    return this.signMessageSync(message, signingContext);
+  }
+
   /**
    * Internal: sign a transaction and return both the raw serialized transaction
    * and the signer-computed transaction hash. The hash is later used to
@@ -428,7 +504,7 @@ class Wallet extends BaseWallet {
     // decision, not a local change.)
     const pw = typeof password === "string"
       ? password.normalize("NFC")
-      : Buffer.from(arrayify(password)).toString("utf8").normalize("NFC");
+      : bytesToUtf8(arrayify(password)).normalize("NFC");
     assertSecretArgument(pw.length >= 12, "password must be at least 12 characters", "password");
     const json = qcsdk.serializeEncryptedWallet(this._qcWallet, pw);
     if (typeof json !== "string") throw makeError("serializeEncryptedWallet failed", "UNKNOWN_ERROR", {});
@@ -455,7 +531,7 @@ class Wallet extends BaseWallet {
     // (cross-app interop); prefer string passphrases.
     const pw = typeof password === "string"
       ? password.normalize("NFC")
-      : Buffer.from(arrayify(password)).toString("utf8").normalize("NFC");
+      : bytesToUtf8(arrayify(password)).normalize("NFC");
     assertSecretArgument(pw.length >= 12, "password must be at least 12 characters", "password");
     const json = qcsdk.serializeSeedAsEncryptedWallet(seedArr, pw);
     if (typeof json !== "string") throw makeError("serializeSeedAsEncryptedWallet failed", "UNKNOWN_ERROR", {});
@@ -739,6 +815,39 @@ class VoidSigner extends AbstractSigner {
   }
 }
 
+/**
+ * Recover the signer's 32-byte address from an EIP-191 message signature.
+ *
+ * QuantumCoin has no ECDSA `ecrecover`: signatures are opaque post-quantum blobs
+ * that embed the signer's public key. This function re-derives the EIP-191
+ * digest with {@link hashMessage}, extracts and cryptographically verifies the
+ * embedded public key against that digest via
+ * `quantum-coin-js-sdk.publicKeyFromSignature`, and returns the corresponding
+ * 32-byte address. If the signature does not verify there is nothing to recover,
+ * so the function throws.
+ *
+ * Synchronous, matching ethers' `verifyMessage` (there is no async variant).
+ *
+ * @param {string|Uint8Array} message The original message (strings are UTF-8 encoded).
+ * @param {string|Uint8Array} signature The signature produced by `signMessage`.
+ * @returns {string} 0x-prefixed 32-byte signer address.
+ * @throws {TypeError} INVALID_ARGUMENT if the signature is malformed or does not verify.
+ */
+function verifyMessage(message, signature) {
+  _requireInitialized();
+  const digestHex = hashMessage(message);
+  const digestArr = _bytesToNumberArray(hexToBytes(digestHex));
+  const sigArr = _bytesToNumberArray(arrayify(signature));
+  const pubHex = qcsdk.publicKeyFromSignature(digestArr, sigArr);
+  if (typeof pubHex !== "string") {
+    throw makeError("verifyMessage failed: signature did not verify", "INVALID_ARGUMENT", {
+      argument: "signature",
+      value: "[signature]",
+    });
+  }
+  return computeAddress(pubHex);
+}
+
 module.exports = {
   SigningKey,
   AbstractSigner,
@@ -747,5 +856,6 @@ module.exports = {
   NonceManager,
   JsonRpcSigner,
   VoidSigner,
+  verifyMessage,
 };
 

package/.github/workflows/publish-npmjs.yaml

@@ -1,22 +0,0 @@
-name: Publish Package to npmjs
-on:
-  workflow_dispatch:
-  
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write    
-    steps:
-      - uses: actions/checkout@v4
-      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm install
-      - run: npm ci      
-      - run: npm publish --provenance --access public --otp=${{ secrets.OTP }}
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.gitignore

@@ -1,15 +0,0 @@
-node_modules/**
-output/**
-examples/node_modules/**
-examples/example-generated-sdk-ts/**
-examples/example-generated-sdk-js/**
-test/e2e/generated-sdks/**
-**/*.save
-**/*.swp
-**/*.tgz
-dist/
-.idea
-.vscode
-**/.DS_Store
-
-.iterm2-project

package/examples/AllSolidityTypes.sol

@@ -1,184 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.7.6;
-pragma experimental ABIEncoderV2;
-
-/// @title AllSolidityTypes
-/// @notice A Solidity 0.7.6 contract that exercises a wide surface of ABI-encodable types.
-/// @dev
-/// - Includes: bool, all int/uint widths, address/address payable, string, bytes, bytes1..bytes32
-/// - Includes: enums, nested structs, fixed/dynamic arrays, arrays of structs, structs of structs
-/// - Excludes: fixed-point types and function types (by request)
-/// - Note: mappings are not ABI-encodable, so they are shown only as a storage type.
-contract AllSolidityTypes {
-  enum Choice { None, One, Two }
-
-  // Mapping example (not ABI-encodable as param/return)
-  mapping(address => uint256) private _balances;
-
-  // --------------------------------------------------------------------------
-  // All integer widths
-  // --------------------------------------------------------------------------
-  struct AllUints {
-    uint8 u8; uint16 u16; uint24 u24; uint32 u32; uint40 u40; uint48 u48; uint56 u56; uint64 u64;
-    uint72 u72; uint80 u80; uint88 u88; uint96 u96; uint104 u104; uint112 u112; uint120 u120; uint128 u128;
-    uint136 u136; uint144 u144; uint152 u152; uint160 u160; uint168 u168; uint176 u176; uint184 u184; uint192 u192;
-    uint200 u200; uint208 u208; uint216 u216; uint224 u224; uint232 u232; uint240 u240; uint248 u248; uint256 u256;
-  }
-
-  struct AllInts {
-    int8 i8; int16 i16; int24 i24; int32 i32; int40 i40; int48 i48; int56 i56; int64 i64;
-    int72 i72; int80 i80; int88 i88; int96 i96; int104 i104; int112 i112; int120 i120; int128 i128;
-    int136 i136; int144 i144; int152 i152; int160 i160; int168 i168; int176 i176; int184 i184; int192 i192;
-    int200 i200; int208 i208; int216 i216; int224 i224; int232 i232; int240 i240; int248 i248; int256 i256;
-  }
-
-  // --------------------------------------------------------------------------
-  // All fixed-size bytes
-  // --------------------------------------------------------------------------
-  struct AllFixedBytes {
-    bytes1 b1; bytes2 b2; bytes3 b3; bytes4 b4; bytes5 b5; bytes6 b6; bytes7 b7; bytes8 b8;
-    bytes9 b9; bytes10 b10; bytes11 b11; bytes12 b12; bytes13 b13; bytes14 b14; bytes15 b15; bytes16 b16;
-    bytes17 b17; bytes18 b18; bytes19 b19; bytes20 b20; bytes21 b21; bytes22 b22; bytes23 b23; bytes24 b24;
-    bytes25 b25; bytes26 b26; bytes27 b27; bytes28 b28; bytes29 b29; bytes30 b30; bytes31 b31; bytes32 b32;
-  }
-
-  // --------------------------------------------------------------------------
-  // Misc ABI value types (plus arrays)
-  // --------------------------------------------------------------------------
-  struct AllMisc {
-    bool bo;
-    address addr;
-    address payable payableAddr;
-    string str;
-    bytes dynBytes;
-    Choice choice;
-    // Arrays of elementary types
-    uint256[] u256s;
-    int256[] i256s;
-    bytes32[] b32s;
-    address[] addrs;
-    bool[] bools;
-    string[] strings;
-    bytes[] bytesArr;
-    // Fixed arrays
-    uint16[3] fixedU16;
-    bytes32[2] fixedB32;
-  }
-
-  // Nested struct that contains structs and arrays of structs
-  struct Inner {
-    AllUints u;
-    AllInts i;
-    AllFixedBytes fb;
-    AllMisc misc;
-    // Array of structs
-    AllUints[] uStructs;
-    // Struct of structs
-    AllFixedBytes[2] fixedFb;
-    // Nested arrays
-    uint256[][] matrix;
-  }
-
-  struct Outer {
-    Inner inner;
-    Inner[] inners;        // dynamic array of structs
-    Inner[2] fixedInners;  // fixed array of structs
-    bytes32[][] b32Matrix;
-  }
-
-  AllUints private _storedU;
-  AllInts private _storedI;
-  AllFixedBytes private _storedFb;
-  AllMisc private _storedMisc;
-
-  /// @notice Constructor with multiple parameters (including structs and arrays).
-  constructor(
-    bool bo,
-    address payable payableAddr,
-    string memory str,
-    bytes memory dynBytes,
-    Choice choice,
-    AllUints memory u,
-    AllInts memory i,
-    AllFixedBytes memory fb,
-    AllMisc memory misc,
-    uint256[] memory seedU256s,
-    bytes32[2] memory seedB32
-  ) {
-    _storedU = u;
-    _storedI = i;
-    _storedFb = fb;
-
-    // Store some misc fields (keep it simple; not all array fields are persisted).
-    _storedMisc.bo = bo;
-    _storedMisc.addr = msg.sender;
-    _storedMisc.payableAddr = payableAddr;
-    _storedMisc.str = str;
-    _storedMisc.dynBytes = dynBytes;
-    _storedMisc.choice = choice;
-    _storedMisc.u256s = seedU256s;
-    _storedMisc.fixedB32 = seedB32;
-
-    // Touch mapping to demonstrate mapping existence.
-    _balances[msg.sender] = seedU256s.length;
-
-    // Use "misc" parameter to avoid unused warnings and ensure ABIEncoderV2 path is exercised.
-    if (misc.fixedU16.length > 0) {
-      _balances[misc.addr] = uint256(misc.fixedU16[0]);
-    }
-  }
-
-  // --------------------------------------------------------------------------
-  // Echo / roundtrip helpers (ABI-encodable inputs and outputs)
-  // --------------------------------------------------------------------------
-
-  function echoAllUints(AllUints memory x) external pure returns (AllUints memory) { return x; }
-  function echoAllInts(AllInts memory x) external pure returns (AllInts memory) { return x; }
-  function echoAllFixedBytes(AllFixedBytes memory x) external pure returns (AllFixedBytes memory) { return x; }
-  function echoAllMisc(AllMisc memory x) external pure returns (AllMisc memory) { return x; }
-
-  function echoInner(Inner memory x) external pure returns (Inner memory) { return x; }
-  function echoOuter(Outer memory x) external pure returns (Outer memory) { return x; }
-
-  // Arrays of structs and nested arrays
-  function echoAllUintsArray(AllUints[] memory xs) external pure returns (AllUints[] memory) { return xs; }
-  function echoInnerArray(Inner[] memory xs) external pure returns (Inner[] memory) { return xs; }
-  function echoMatrix(uint256[][] memory m) external pure returns (uint256[][] memory) { return m; }
-
-  // Multiple input params + multiple return params
-  function multiReturn(
-    bool bo,
-    address addr,
-    bytes32 b32,
-    string memory s,
-    uint256 x,
-    AllUints memory u
-  )
-    external
-    pure
-    returns (
-      bool outBo,
-      address outAddr,
-      address payable outPayableAddr,
-      bytes32 outB32,
-      string memory outS,
-      uint256 outX,
-      AllUints memory outU
-    )
-  {
-    outBo = bo;
-    outAddr = addr;
-    outPayableAddr = payable(addr);
-    outB32 = b32;
-    outS = s;
-    outX = x;
-    outU = u;
-  }
-
-  // Read-only getters to provide outputs without inputs
-  function getStoredUints() external view returns (AllUints memory) { return _storedU; }
-  function getStoredInts() external view returns (AllInts memory) { return _storedI; }
-  function getStoredFixedBytes() external view returns (AllFixedBytes memory) { return _storedFb; }
-  function getStoredMisc() external view returns (AllMisc memory) { return _storedMisc; }
-}
-

package/examples/SimpleIERC20.sol

@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.7.6;
-
-/// @title IERC20
-/// @notice Minimal ERC-20 interface (standard ABI surface).
-interface IERC20 {
-  event Transfer(address indexed from, address indexed to, uint256 value);
-  event Approval(address indexed owner, address indexed spender, uint256 value);
-
-  function totalSupply() external view returns (uint256);
-  function balanceOf(address account) external view returns (uint256);
-  function allowance(address owner, address spender) external view returns (uint256);
-
-  function transfer(address to, uint256 value) external returns (bool);
-  function approve(address spender, uint256 value) external returns (bool);
-  function transferFrom(address from, address to, uint256 value) external returns (bool);
-}
-
-/// @title SimpleERC20
-/// @notice A small deployable ERC-20 implementation for generator examples.
-contract SimpleERC20 is IERC20 {
-  string public name;
-  string public symbol;
-  uint8 public constant decimals = 18;
-
-  uint256 public override totalSupply;
-  mapping(address => uint256) public override balanceOf;
-  mapping(address => mapping(address => uint256)) public override allowance;
-
-  constructor(string memory _name, string memory _symbol, uint256 _initialSupply) {
-    name = _name;
-    symbol = _symbol;
-    _mint(msg.sender, _initialSupply);
-  }
-
-  function transfer(address to, uint256 value) external override returns (bool) {
-    _transfer(msg.sender, to, value);
-    return true;
-  }
-
-  function approve(address spender, uint256 value) external override returns (bool) {
-    allowance[msg.sender][spender] = value;
-    emit Approval(msg.sender, spender, value);
-    return true;
-  }
-
-  function transferFrom(address from, address to, uint256 value) external override returns (bool) {
-    uint256 allowed = allowance[from][msg.sender];
-    require(allowed >= value, "ALLOWANCE");
-    if (allowed != uint256(-1)) {
-      allowance[from][msg.sender] = allowed - value;
-      emit Approval(from, msg.sender, allowance[from][msg.sender]);
-    }
-    _transfer(from, to, value);
-    return true;
-  }
-
-  function _transfer(address from, address to, uint256 value) internal {
-    require(to != address(0), "TO_ZERO");
-    uint256 bal = balanceOf[from];
-    require(bal >= value, "BALANCE");
-    balanceOf[from] = bal - value;
-    balanceOf[to] += value;
-    emit Transfer(from, to, value);
-  }
-
-  function _mint(address to, uint256 value) internal {
-    require(to != address(0), "MINT_TO_ZERO");
-    totalSupply += value;
-    balanceOf[to] += value;
-    emit Transfer(address(0), to, value);
-  }
-}
-

package/examples/events.js

@@ -1,41 +0,0 @@
-/**
- * Example: Querying logs/events (read-only).
- * Run with VERBOSE=1 for addresses, block range, and log counts.
- *
- * Note: This is a simple log query example; it does not keep a live subscription
- * running. For long-running subscriptions, build on Provider polling or a future
- * WebSocketProvider implementation.
- */
-
-const { Initialize } = require("../config");
-const { getProvider, Contract } = require("..");
-const { logExample, logAddress } = require("../test/verbose-logger");
-
-const RPC = "https://public.rpc.quantumcoinapi.com";
-const CHAIN_ID = 123123;
-const STAKING_CONTRACT = "0x" + "00".repeat(30) + "10" + "00"; // 0x...1000
-
-async function eventsExample() {
-  logExample("events.js", "starting", { rpc: RPC, chainId: CHAIN_ID });
-  await Initialize(null);
-
-  const provider = getProvider(RPC, CHAIN_ID);
-  logAddress("staking_contract", STAKING_CONTRACT);
-  const abi = require("../test/fixtures/StakingContract.abi.json");
-  const contract = new Contract(STAKING_CONTRACT, abi, provider);
-
-  // Query recent logs from the last 1000 blocks
-  const latest = await provider.getBlockNumber();
-  const fromBlock = Math.max(latest - 1000, 0);
-  logExample("events.js", "block range", { latest, fromBlock, toBlock: "latest" });
-
-  const logs = await contract.queryFilter("OnNewDeposit", fromBlock, "latest");
-  console.log(`Found ${logs.length} OnNewDeposit logs in last 1000 blocks`);
-  logExample("events.js", "queryFilter OnNewDeposit", { logCount: logs.length });
-}
-
-eventsExample().catch((e) => {
-  console.error(e);
-  process.exitCode = 1;
-});
-