quantumcoin 6.14.1 → 6.14.2

package/src.ts/providers/network.ts

@@ -6,10 +6,10 @@
  */
 
 import { accessListify } from "../transaction/index.js";
-import { getBigInt, assert, assertArgument } from "../utils/index.js";
+import { getBigInt, assertArgument } from "../utils/index.js";
 
 import {
-    EnsPlugin, FetchUrlFeeDataNetworkPlugin, GasCostPlugin
+    EnsPlugin, GasCostPlugin
 } from "./plugins-network.js";
 
 import type { BigNumberish } from "../utils/index.js";
@@ -288,65 +288,6 @@ type Options = {
     plugins?: Array<NetworkPlugin>;
 };
 
-// We don't want to bring in formatUnits because it is backed by
-// FixedNumber and we want to keep Networks tiny. The values
-// included by the Gas Stations are also IEEE 754 with lots of
-// rounding issues and exceed the strict checks formatUnits has.
-function parseUnits(_value: number | string, decimals: number): bigint {
-    const value = String(_value);
-    if (!value.match(/^[0-9.]+$/)) {
-        throw new Error(`invalid gwei value: ${ _value }`);
-    }
-
-    // Break into [ whole, fraction ]
-    const comps = value.split(".");
-    if (comps.length === 1) { comps.push(""); }
-
-    // More than 1 decimal point or too many fractional positions
-    if (comps.length !== 2) {
-        throw new Error(`invalid gwei value: ${ _value }`);
-    }
-
-    // Pad the fraction to 9 decimalplaces
-    while (comps[1].length < decimals) { comps[1] += "0"; }
-
-    // Too many decimals and some non-zero ending, take the ceiling
-    if (comps[1].length > 9) {
-        let frac = BigInt(comps[1].substring(0, 9));
-        if (!comps[1].substring(9).match(/^0+$/)) { frac++; }
-        comps[1] = frac.toString();
-    }
-
-    return BigInt(comps[0] + comps[1]);
-}
-
-// Used by Polygon to use a gas station for fee data
-function getGasStationPlugin(url: string) {
-    return new FetchUrlFeeDataNetworkPlugin(url, async (fetchFeeData, provider, request) => {
-
-        // Prevent Cloudflare from blocking our request in node.js
-        request.setHeader("User-Agent", "ethers");
-
-        let response;
-        try {
-            const [ _response, _feeData ] = await Promise.all([
-                request.send(), fetchFeeData()
-            ]);
-            response = _response;
-            const payload = response.bodyJson.standard;
-            const feeData = {
-                gasPrice: _feeData.gasPrice,
-                maxFeePerGas: parseUnits(payload.maxFee, 9),
-                maxPriorityFeePerGas: parseUnits(payload.maxPriorityFee, 9),
-            };
-            return feeData;
-        } catch (error: any) {
-            assert(false, `error encountered with polygon gas station (${ JSON.stringify(request.url) })`, "SERVER_ERROR", { request, response, error });
-        }
-    });
-}
-
-// See: https://chainlist.org
 let injected = false;
 function injectCommonNetworks(): void {
     if (injected) { return; }
@@ -382,54 +323,5 @@ function injectCommonNetworks(): void {
         }
     }
 
-    registerEth("mainnet", 1, { ensNetwork: 1, altNames: [ "homestead" ] });
-    registerEth("ropsten", 3, { ensNetwork: 3 });
-    registerEth("rinkeby", 4, { ensNetwork: 4 });
-    registerEth("goerli", 5, { ensNetwork: 5 });
-    registerEth("kovan", 42, { ensNetwork: 42 });
-    registerEth("sepolia", 11155111, { ensNetwork: 11155111 });
-    registerEth("holesky", 17000, { ensNetwork: 17000 });
-
-    registerEth("classic", 61, { });
-    registerEth("classicKotti", 6, { });
-
-    registerEth("arbitrum", 42161, {
-        ensNetwork: 1,
-    });
-    registerEth("arbitrum-goerli", 421613, { });
-    registerEth("arbitrum-sepolia", 421614, { });
-
-    registerEth("base", 8453, { ensNetwork: 1 });
-    registerEth("base-goerli", 84531, { });
-    registerEth("base-sepolia", 84532, { });
-
-    registerEth("bnb", 56, { ensNetwork: 1 });
-    registerEth("bnbt", 97, { });
-
-    registerEth("linea", 59144, { ensNetwork: 1 });
-    registerEth("linea-goerli", 59140, { });
-    registerEth("linea-sepolia", 59141, { });
-
-    registerEth("matic", 137, {
-        ensNetwork: 1,
-        plugins: [
-            getGasStationPlugin("https:/\/gasstation.polygon.technology/v2")
-        ]
-    });
-    registerEth("matic-amoy", 80002, { });
-    registerEth("matic-mumbai", 80001, {
-        altNames: [ "maticMumbai", "maticmum" ],  // @TODO: Future remove these alts
-        plugins: [
-            getGasStationPlugin("https:/\/gasstation-testnet.polygon.technology/v2")
-        ]
-    });
-
-    registerEth("optimism", 10, {
-        ensNetwork: 1,
-        plugins: [ ]
-    });
-    registerEth("optimism-goerli", 420, { });
-    registerEth("optimism-sepolia", 11155420, { });
-
-    registerEth("xdai", 100, { ensNetwork: 1 });
+    registerEth("mainnet", 123123, { ensNetwork: 1, altNames: [ "quantumcoin" ] });
 }

package/src.ts/quantumcoin.ts

@@ -16,7 +16,7 @@ export {
 } from "./abi/index.js";
 
 export {
-    getAddress, getIcapAddress,
+    getAddress,
     getCreateAddress, getCreate2Address,
     isAddressable, isAddress, resolveAddress
 } from "./address/index.js";
@@ -70,16 +70,12 @@ export {
 
     BrowserProvider,
 
-    AlchemyProvider, AnkrProvider, BlockscoutProvider, ChainstackProvider,
-    CloudflareProvider, EtherscanProvider, InfuraProvider,
-    InfuraWebSocketProvider, PocketProvider, QuickNodeProvider,
-
     IpcSocketProvider, SocketProvider, WebSocketProvider,
 
     EnsResolver,
     Network,
 
-    EnsPlugin, EtherscanPlugin,
+    EnsPlugin,
     FeeDataNetworkPlugin, FetchUrlFeeDataNetworkPlugin,
     GasCostPlugin, NetworkPlugin, MulticoinProviderPlugin,
 
@@ -117,17 +113,11 @@ export {
 } from "./utils/index.js";
 
 export {
-    Mnemonic,
-    BaseWallet, HDNodeWallet, HDNodeVoidWallet,
+    BaseWallet,
     Wallet,
-
-    defaultPath,
-
-    getAccountPath, getIndexedAccountPath,
-    isCrowdsaleJson, isKeystoreJson,
-
-    decryptCrowdsaleJson, decryptKeystoreJsonSync, decryptKeystoreJson,
-    encryptKeystoreJson, encryptKeystoreJsonSync,
+    isKeystoreJson,
+    decryptKeystoreJsonSync,
+    encryptKeystoreJsonSync,
 } from "./wallet/index.js";
 
 export {
@@ -215,7 +205,7 @@ export type {
 } from "./utils/index.js";
 
 export type {
-    CrowdsaleAccount, KeystoreAccount, EncryptOptions
+    KeystoreAccount
 } from "./wallet/index.js";
 
 // dummy change; to pick-up ws security issue changes

package/src.ts/transaction/address.ts

@@ -1,8 +1,10 @@
-import { getAddress } from "../address/index.js";
-import { keccak256, SigningKey } from "../crypto/index.js";
+//import { getAddress } from "../address/index.js";
+// keccak256,
+import {SigningKey } from "../crypto/index.js";
 
 import type { SignatureLike } from "../crypto/index.js";
-import type { BytesLike } from "../utils/index.js";
+import {BytesLike, getBytes} from "../utils/index.js";
+import qcsdk = require('quantum-coin-js-sdk');
 
 /**
  *  Returns the address for the %%key%%.
@@ -12,11 +14,12 @@ import type { BytesLike } from "../utils/index.js";
 export function computeAddress(key: string | SigningKey): string {
     let pubkey: string;
     if (typeof(key) === "string") {
-        pubkey = SigningKey.computePublicKey(key, false);
+        pubkey = SigningKey.computePublicKey(key);
     } else {
         pubkey = key.publicKey;
     }
-    return getAddress(keccak256("0x" + pubkey.substring(4)).substring(26));
+    let pubKeyBytes: any = getBytes(pubkey);
+    return qcsdk.addressFromPublicKey(pubKeyBytes);
 }
 
 /**

package/src.ts/wallet/index.ts

@@ -19,29 +19,14 @@
 
 export { BaseWallet } from "./base-wallet.js";
 
-export {
-    defaultPath,
-
-    getAccountPath, getIndexedAccountPath,
-
-    HDNodeWallet,
-    HDNodeVoidWallet,
-} from "./hdwallet.js";
-
-export { isCrowdsaleJson, decryptCrowdsaleJson } from "./json-crowdsale.js";
-
 export {
     isKeystoreJson,
-    decryptKeystoreJsonSync, decryptKeystoreJson,
-    encryptKeystoreJson, encryptKeystoreJsonSync
+    decryptKeystoreJsonSync, encryptKeystoreJsonSync
 } from "./json-keystore.js";
 
-export { Mnemonic } from "./mnemonic.js";
-
 export { Wallet } from "./wallet.js";
 
 
-export type { CrowdsaleAccount } from "./json-crowdsale.js";
 export type {
-    KeystoreAccount, EncryptOptions
+    KeystoreAccount
 } from "./json-keystore.js"

package/src.ts/wallet/json-keystore.ts

@@ -9,24 +9,31 @@
  *  @_subsection: api/wallet:JSON Wallets  [json-wallets]
  */
 
-import { CTR } from "aes-js";
+//import { CTR } from "aes-js";
 
-import { getAddress } from "../address/index.js";
-import { keccak256, pbkdf2, randomBytes, scrypt, scryptSync } from "../crypto/index.js";
-import { computeAddress } from "../transaction/index.js";
+//import { getAddress } from "../address/index.js";
+//randomBytes, scrypt, scryptSync, uuidV4
+//import { keccak256  } from "../crypto/index.js";
+//import { computeAddress } from "../transaction/index.js";
+//concat, assert, assertArgument,
 import {
-    concat, getBytes, hexlify, uuidV4, assert, assertArgument
+    getBytes, hexlify, toUtf8String
 } from "../utils/index.js";
 
-import { getPassword, spelunk, zpad } from "./utils.js";
+import {SigningKey} from "../crypto/signing-key"
 
-import type { ProgressCallback } from "../crypto/index.js";
-import type { BytesLike } from "../utils/index.js";
+//zpad
+//import { spelunk } from "./utils.js";
 
-import { version } from "../_version.js";
+//import type { ProgressCallback } from "../crypto/index.js";
+//import {Wallet} from "quantum-coin-js-sdk";
+//import type { BytesLike } from "../utils/index.js";
+import qcsdk = require('quantum-coin-js-sdk');
 
+//import { version } from "../_version.js";
 
-const defaultPath = "m/44'/60'/0'/0/0";
+
+//const defaultPath = "m/44'/60'/0'/0/0";
 
 /**
  *  The contents of a JSON Keystore Wallet.
@@ -34,30 +41,8 @@ const defaultPath = "m/44'/60'/0'/0/0";
 export type KeystoreAccount = {
     address: string;
     privateKey: string;
-    mnemonic?: {
-        path?: string;
-        locale?: string;
-        entropy: string;
-    }
 };
 
-/**
- *  The parameters to use when encrypting a JSON Keystore Wallet.
- */
-export type EncryptOptions = {
-   progressCallback?: ProgressCallback;
-   iv?: BytesLike;
-   entropy?: BytesLike;
-   client?: string;
-   salt?: BytesLike;
-   uuid?: string;
-   scrypt?: {
-       N?: number;
-       r?: number;
-       p?: number;
-   }
-}
-
 /**
  *  Returns true if %%json%% is a valid JSON Keystore Wallet.
  */
@@ -70,150 +55,6 @@ export function isKeystoreJson(json: string): boolean {
     return false;
 }
 
-function decrypt(data: any, key: Uint8Array, ciphertext: Uint8Array): string {
-    const cipher = spelunk<string>(data, "crypto.cipher:string");
-    if (cipher === "aes-128-ctr") {
-        const iv = spelunk<Uint8Array>(data, "crypto.cipherparams.iv:data!")
-        const aesCtr = new CTR(key, iv);
-        return hexlify(aesCtr.decrypt(ciphertext));
-    }
-
-    assert(false, "unsupported cipher", "UNSUPPORTED_OPERATION", {
-        operation: "decrypt"
-    });
-}
-
-function getAccount(data: any, _key: string): KeystoreAccount {
-    const key = getBytes(_key);
-    const ciphertext = spelunk<Uint8Array>(data, "crypto.ciphertext:data!");
-
-    const computedMAC = hexlify(keccak256(concat([ key.slice(16, 32), ciphertext ]))).substring(2);
-    assertArgument(computedMAC === spelunk<string>(data, "crypto.mac:string!").toLowerCase(),
-        "incorrect password", "password", "[ REDACTED ]");
-
-    const privateKey = decrypt(data, key.slice(0, 16), ciphertext);
-
-    const address = computeAddress(privateKey);
-    if (data.address) {
-        let check = data.address.toLowerCase();
-        if (!check.startsWith("0x")) { check = "0x" + check; }
-
-        assertArgument(getAddress(check) === address, "keystore address/privateKey mismatch", "address", data.address);
-    }
-
-    const account: KeystoreAccount = { address, privateKey };
-
-    // Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase
-    const version = spelunk(data, "x-ethers.version:string");
-    if (version === "0.1") {
-        const mnemonicKey = key.slice(32, 64);
-
-        const mnemonicCiphertext = spelunk<Uint8Array>(data, "x-ethers.mnemonicCiphertext:data!");
-        const mnemonicIv = spelunk<Uint8Array>(data, "x-ethers.mnemonicCounter:data!");
-
-        const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);
-
-        account.mnemonic = {
-            path: (spelunk<null | string>(data, "x-ethers.path:string") || defaultPath),
-            locale: (spelunk<null | string>(data, "x-ethers.locale:string") || "en"),
-            entropy: hexlify(getBytes(mnemonicAesCtr.decrypt(mnemonicCiphertext)))
-        };
-    }
-
-    return account;
-}
-
-type ScryptParams = {
-    name: "scrypt";
-    salt: Uint8Array;
-    N: number;
-    r: number;
-    p: number;
-    dkLen: number;
-};
-
-type KdfParams = ScryptParams | {
-    name: "pbkdf2";
-    salt: Uint8Array;
-    count: number;
-    dkLen: number;
-    algorithm: "sha256" | "sha512";
-};
-
-function getDecryptKdfParams<T>(data: any): KdfParams {
-    const kdf = spelunk(data, "crypto.kdf:string");
-    if (kdf && typeof(kdf) === "string") {
-        if (kdf.toLowerCase() === "scrypt") {
-            const salt = spelunk<Uint8Array>(data, "crypto.kdfparams.salt:data!");
-            const N = spelunk<number>(data, "crypto.kdfparams.n:int!");
-            const r = spelunk<number>(data, "crypto.kdfparams.r:int!");
-            const p = spelunk<number>(data, "crypto.kdfparams.p:int!");
-
-            // Make sure N is a power of 2
-            assertArgument(N > 0 && (N & (N - 1)) === 0, "invalid kdf.N", "kdf.N", N);
-            assertArgument(r > 0 && p > 0, "invalid kdf", "kdf", kdf);
-
-            const dkLen = spelunk<number>(data, "crypto.kdfparams.dklen:int!");
-            assertArgument(dkLen === 32, "invalid kdf.dklen", "kdf.dflen", dkLen);
-
-            return { name: "scrypt", salt, N, r, p, dkLen: 64 };
-
-        } else if (kdf.toLowerCase() === "pbkdf2") {
-
-            const salt = spelunk<Uint8Array>(data, "crypto.kdfparams.salt:data!");
-
-            const prf = spelunk<string>(data, "crypto.kdfparams.prf:string!");
-            const algorithm = prf.split("-").pop();
-            assertArgument(algorithm === "sha256" || algorithm === "sha512", "invalid kdf.pdf", "kdf.pdf", prf);
-
-            const count = spelunk<number>(data, "crypto.kdfparams.c:int!");
-
-            const dkLen = spelunk<number>(data, "crypto.kdfparams.dklen:int!");
-            assertArgument(dkLen === 32, "invalid kdf.dklen", "kdf.dklen", dkLen);
-
-            return { name: "pbkdf2", salt, count, dkLen, algorithm };
-        }
-    }
-
-    assertArgument(false, "unsupported key-derivation function", "kdf", kdf);
-}
-
-
-/**
- *  Returns the account details for the JSON Keystore Wallet %%json%%
- *  using %%password%%.
- *
- *  It is preferred to use the [async version](decryptKeystoreJson)
- *  instead, which allows a [[ProgressCallback]] to keep the user informed
- *  as to the decryption status.
- *
- *  This method will block the event loop (freezing all UI) until decryption
- *  is complete, which can take quite some time, depending on the wallet
- *  paramters and platform.
- */
-export function decryptKeystoreJsonSync(json: string, _password: string | Uint8Array): KeystoreAccount {
-    const data = JSON.parse(json);
-
-    const password = getPassword(_password);
-
-    const params = getDecryptKdfParams(data);
-    if (params.name === "pbkdf2") {
-        const { salt, count, dkLen, algorithm } = params;
-        const key = pbkdf2(password, salt, count, dkLen, algorithm);
-        return getAccount(data, key);
-    }
-
-    assert(params.name === "scrypt", "cannot be reached", "UNKNOWN_ERROR", { params })
-
-    const { salt, N, r, p, dkLen } = params;
-    const key = scryptSync(password, salt, N, r, p, dkLen);
-    return getAccount(data, key);
-}
-
-function stall(duration: number): Promise<void> {
-    return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); });
-}
-
 /**
  *  Resolves to the decrypted JSON Keystore Wallet %%json%% using the
  *  %%password%%.
@@ -221,152 +62,24 @@ function stall(duration: number): Promise<void> {
  *  If provided, %%progress%% will be called periodically during the
  *  decrpytion to provide feedback, and if the function returns
  *  ``false`` will halt decryption.
- *
- *  The %%progressCallback%% will **always** receive ``0`` before
- *  decryption begins and ``1`` when complete.
  */
-export async function decryptKeystoreJson(json: string, _password: string | Uint8Array, progress?: ProgressCallback): Promise<KeystoreAccount> {
-    const data = JSON.parse(json);
-
-    const password = getPassword(_password);
-
-    const params = getDecryptKdfParams(data);
-    if (params.name === "pbkdf2") {
-        if (progress) {
-            progress(0);
-            await stall(0);
-        }
-        const { salt, count, dkLen, algorithm } = params;
-        const key = pbkdf2(password, salt, count, dkLen, algorithm);
-        if (progress) {
-            progress(1);
-            await stall(0);
-        }
-        return getAccount(data, key);
-    }
-
-    assert(params.name === "scrypt", "cannot be reached", "UNKNOWN_ERROR", { params })
-
-    const { salt, N, r, p, dkLen } = params;
-    const key = await scrypt(password, salt, N, r, p, dkLen, progress);
-    return getAccount(data, key);
-}
-
-function getEncryptKdfParams(options: EncryptOptions): ScryptParams {
-    // Check/generate the salt
-    const salt = (options.salt != null) ? getBytes(options.salt, "options.salt"): randomBytes(32);
-
-    // Override the scrypt password-based key derivation function parameters
-    let N = (1 << 17), r = 8, p = 1;
-    if (options.scrypt) {
-        if (options.scrypt.N) { N = options.scrypt.N; }
-        if (options.scrypt.r) { r = options.scrypt.r; }
-        if (options.scrypt.p) { p = options.scrypt.p; }
+export function decryptKeystoreJsonSync(json: string, _password: string | Uint8Array): KeystoreAccount {
+    let pass: string;
+    if (typeof _password === 'string') {
+        pass = _password;
+    } else {
+        pass =  toUtf8String(_password);
     }
-    assertArgument(typeof(N) === "number" && N > 0 && Number.isSafeInteger(N) && (BigInt(N) & BigInt(N - 1)) === BigInt(0), "invalid scrypt N parameter", "options.N", N);
-    assertArgument(typeof(r) === "number" && r > 0 && Number.isSafeInteger(r), "invalid scrypt r parameter", "options.r", r);
-    assertArgument(typeof(p) === "number" && p > 0 && Number.isSafeInteger(p), "invalid scrypt p parameter", "options.p", p);
-
-    return { name: "scrypt", dkLen: 32, salt, N, r, p };
-}
-
-function _encryptKeystore(key: Uint8Array, kdf: ScryptParams, account: KeystoreAccount, options: EncryptOptions): any {
 
-    const privateKey = getBytes(account.privateKey, "privateKey");
+    let wal = qcsdk.deserializeEncryptedWallet(json, pass);
+    let privKey: any = wal.privateKey;
 
-    // Override initialization vector
-    const iv = (options.iv != null) ? getBytes(options.iv, "options.iv"): randomBytes(16);
-    assertArgument(iv.length === 16, "invalid options.iv length", "options.iv", options.iv);
-
-    // Override the uuid
-    const uuidRandom = (options.uuid != null) ? getBytes(options.uuid, "options.uuid"): randomBytes(16);
-    assertArgument(uuidRandom.length === 16, "invalid options.uuid length", "options.uuid", options.iv);
-
-    // This will be used to encrypt the wallet (as per Web3 secret storage)
-    // - 32 bytes   As normal for the Web3 secret storage (derivedKey, macPrefix)
-    // - 32 bytes   AES key to encrypt mnemonic with (required here to be Ethers Wallet)
-    const derivedKey = key.slice(0, 16);
-    const macPrefix = key.slice(16, 32);
-
-    // Encrypt the private key
-    const aesCtr = new CTR(derivedKey, iv);
-    const ciphertext = getBytes(aesCtr.encrypt(privateKey));
-
-    // Compute the message authentication code, used to check the password
-    const mac = keccak256(concat([ macPrefix, ciphertext ]))
-
-    // See: https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition
-    const data: { [key: string]: any } = {
-        address: account.address.substring(2).toLowerCase(),
-        id: uuidV4(uuidRandom),
-        version: 3,
-        Crypto: {
-            cipher: "aes-128-ctr",
-            cipherparams: {
-                iv: hexlify(iv).substring(2),
-            },
-            ciphertext: hexlify(ciphertext).substring(2),
-            kdf: "scrypt",
-            kdfparams: {
-                salt: hexlify(kdf.salt).substring(2),
-                n: kdf.N,
-                dklen: 32,
-                p: kdf.p,
-                r: kdf.r
-            },
-            mac: mac.substring(2)
-        }
+    let ks: KeystoreAccount = {
+        address: wal.address,
+        privateKey: hexlify(privKey)
     };
 
-    // If we have a mnemonic, encrypt it into the JSON wallet
-    if (account.mnemonic) {
-        const client = (options.client != null) ? options.client: `ethers/${ version }`;
-
-        const path = account.mnemonic.path || defaultPath;
-        const locale = account.mnemonic.locale || "en";
-
-        const mnemonicKey = key.slice(32, 64);
-
-        const entropy = getBytes(account.mnemonic.entropy, "account.mnemonic.entropy");
-        const mnemonicIv = randomBytes(16);
-        const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);
-        const mnemonicCiphertext = getBytes(mnemonicAesCtr.encrypt(entropy));
-
-        const now = new Date();
-        const timestamp = (now.getUTCFullYear() + "-" +
-                           zpad(now.getUTCMonth() + 1, 2) + "-" +
-                           zpad(now.getUTCDate(), 2) + "T" +
-                           zpad(now.getUTCHours(), 2) + "-" +
-                           zpad(now.getUTCMinutes(), 2) + "-" +
-                           zpad(now.getUTCSeconds(), 2) + ".0Z");
-        const gethFilename = ("UTC--" + timestamp + "--" + data.address);
-
-        data["x-ethers"] = {
-            client, gethFilename, path, locale,
-            mnemonicCounter: hexlify(mnemonicIv).substring(2),
-            mnemonicCiphertext: hexlify(mnemonicCiphertext).substring(2),
-            version: "0.1"
-        };
-    }
-
-    return JSON.stringify(data);
-}
-
-/**
- *  Return the JSON Keystore Wallet for %%account%% encrypted with
- *  %%password%%.
- *
- *  The %%options%% can be used to tune the password-based key
- *  derivation function parameters, explicitly set the random values
- *  used. Any provided [[ProgressCallback]] is ignord.
- */
-export function encryptKeystoreJsonSync(account: KeystoreAccount, password: string | Uint8Array, options?: EncryptOptions): string {
-    if (options == null) { options = { }; }
-
-    const passwordBytes = getPassword(password);
-    const kdf = getEncryptKdfParams(options);
-    const key = scryptSync(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64);
-    return _encryptKeystore(getBytes(key), kdf, account, options);
+    return ks;
 }
 
 /**
@@ -375,15 +88,19 @@ export function encryptKeystoreJsonSync(account: KeystoreAccount, password: stri
  *
  *  The %%options%% can be used to tune the password-based key
  *  derivation function parameters, explicitly set the random values
- *  used and provide a [[ProgressCallback]] to receive periodic updates
- *  on the completion status..
+ *  used.
  */
-export async function encryptKeystoreJson(account: KeystoreAccount, password: string | Uint8Array, options?: EncryptOptions): Promise<string> {
-    if (options == null) { options = { }; }
-
-    const passwordBytes = getPassword(password);
-    const kdf = getEncryptKdfParams(options);
-    const key = await scrypt(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64, options.progressCallback);
-    return _encryptKeystore(getBytes(key), kdf, account, options);
+export function encryptKeystoreJsonSync(account: KeystoreAccount, password: Uint8Array | string): string {
+    const signingKey: SigningKey = new SigningKey(account.privateKey);
+    const privateKey: any = getBytes(signingKey.privateKey);
+    const publicKey: any = getBytes(signingKey.publicKey);
+    const wal = new qcsdk.Wallet(account.address, privateKey, publicKey);
+
+    if (typeof password === 'string') {
+        return qcsdk.serializeEncryptedWallet(wal, password);
+    } else {
+        let passPhrase = toUtf8String(password);
+        return qcsdk.serializeEncryptedWallet(wal, passPhrase);
+    }
 }