quais 1.0.0-alpha → 1.0.0-alpha.1

package/dist/quais.js

@@ -18926,7 +18926,10 @@ class QuaiTransaction extends AbstractTransaction {
         if (!this.originZone) {
             throw new Error('Invalid Zone for from address');
         }
-        const isSameLedger = isQiAddress(this.from) === isQiAddress(this.to || '');
+        if (!(this.from && this.to)) {
+            throw new Error('Missing from or to address');
+        }
+        const isSameLedger = isQiAddress(this.from) === isQiAddress(this.to);
         if (this.isExternal && !isSameLedger) {
             throw new Error('Cross-zone & cross-ledger transactions are not supported');
         }
@@ -18945,7 +18948,7 @@ class QuaiTransaction extends AbstractTransaction {
      * The zone of the sender address
      */
     get originZone() {
-        const zone = getZoneForAddress(this.from);
+        const zone = this.from ? getZoneForAddress(this.from) : undefined;
         return zone ?? undefined;
     }
     /**
@@ -19195,8 +19198,8 @@ class QuaiTransaction extends AbstractTransaction {
             assertArgument(result.isSigned(), 'unsigned transaction cannot define hash', 'tx', tx);
         }
         if (tx.from != null) {
-            validateAddress(tx.from);
-            assertArgument(result.from.toLowerCase() === (tx.from || '').toLowerCase(), 'from mismatch', 'tx', tx);
+            assertArgument(!isQiAddress(tx.from), 'from address must be a Quai address', 'tx.from', tx.from);
+            assertArgument((result.from || '').toLowerCase() === (tx.from || '').toLowerCase(), 'from mismatch', 'tx', tx);
             result.from = tx.from;
         }
         return result;
@@ -19327,7 +19330,10 @@ function addressFromTransactionRequest(tx) {
     if (tx.inputs) {
         return getAddress(keccak256('0x' + SigningKey.computePublicKey(tx.inputs[0].pub_key).substring(4)).substring(26));
     }
-    throw new Error('Unable to determine sender from transaction inputs or from field');
+    if ('to' in tx && tx.to !== null) {
+        return tx.to;
+    }
+    throw new Error('Unable to determine address from transaction inputs, from or to field');
 }
 /**
  * Returns a copy of `req` with all properties coerced to their strict types.
@@ -21274,7 +21280,7 @@ function buildWrappedMethod(contract, key) {
         const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);
         return await resolveProperties({
             to: contract.getAddress(),
-            from: args.pop()?.from ?? '0x0000000000000000000000000000000000000000',
+            from: args.pop()?.from,
             data: contract.interface.encodeFunctionData(fragment, resolvedArgs),
         });
     };
@@ -21291,11 +21297,8 @@ function buildWrappedMethod(contract, key) {
             operation: 'sendTransaction',
         });
         const pop = await populateTransaction(...args);
-        if (runner &&
-            'address' in runner &&
-            typeof runner.address == 'string' &&
-            pop.from === '0x0000000000000000000000000000000000000000') {
-            pop.from = runner.address;
+        if (!pop.from && 'address' in runner && typeof runner.address === 'string') {
+            pop.from = await resolveAddress(runner.address);
         }
         const tx = (await runner.sendTransaction(await pop));
         const provider = getProvider(contract.runner);
@@ -21316,11 +21319,8 @@ function buildWrappedMethod(contract, key) {
             operation: 'call',
         });
         const tx = await populateTransaction(...args);
-        if (runner &&
-            'address' in runner &&
-            typeof runner.address == 'string' &&
-            tx.from === '0x0000000000000000000000000000000000000000') {
-            tx.from = runner.address;
+        if (!tx.from && 'address' in runner && typeof runner.address === 'string') {
+            tx.from = await resolveAddress(runner.address);
         }
         let result = '0x';
         try {
@@ -23971,6 +23971,26 @@ class FilterIdPendingSubscriber extends FilterIdSubscriber {
 // @TODO:
 // - Add the batching API
 // https://playground.open-rpc.org/?schemaUrl=https://raw.githubusercontent.com/ethereum/eth1.0-apis/assembled-spec/openrpc.json&uiSchema%5BappBar%5D%5Bui:splitView%5D=true&uiSchema%5BappBar%5D%5Bui:input%5D=false&uiSchema%5BappBar%5D%5Bui:examplesDropdown%5D=false
+const Primitive = 'bigint,boolean,function,number,string,symbol'.split(/,/g);
+function deepCopy(value) {
+    if (value == null || Primitive.indexOf(typeof value) >= 0) {
+        return value;
+    }
+    // Keep any Addressable
+    if (typeof value.getAddress === 'function') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(deepCopy);
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).reduce((accum, key) => {
+            accum[key] = value[key];
+            return accum;
+        }, {});
+    }
+    throw new Error(`should not happen: ${value} (${typeof value})`);
+}
 function stall$1(duration) {
     return new Promise((resolve) => {
         setTimeout(resolve, duration);
@@ -23983,6 +24003,183 @@ const defaultOptions = {
     batchMaxCount: 100,
     cacheTimeout: 250,
 };
+// @TODO: Unchecked Signers
+class JsonRpcSigner extends AbstractSigner {
+    address;
+    constructor(provider, address) {
+        super(provider);
+        address = getAddress(address);
+        defineProperties(this, { address });
+    }
+    // TODO: `provider` is passed in, but not used, remove?
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connect(provider) {
+        assert(false, 'cannot reconnect JsonRpcSigner', 'UNSUPPORTED_OPERATION', {
+            operation: 'signer.connect',
+        });
+    }
+    async getAddress() {
+        return this.address;
+    }
+    // JSON-RPC will automatially fill in nonce, etc. so we just check from
+    async populateQuaiTransaction(tx) {
+        return (await this.populateCall(tx));
+    }
+    // Returns just the hash of the transaction after sent, which is what
+    // the bare JSON-RPC API does;
+    async sendUncheckedTransaction(_tx) {
+        const tx = deepCopy(_tx);
+        const promises = [];
+        if ('from' in tx) {
+            // Make sure the from matches the sender
+            if (tx.from) {
+                const _from = tx.from;
+                promises.push((async () => {
+                    const from = await resolveAddress(_from);
+                    assertArgument(from != null && from.toLowerCase() === this.address.toLowerCase(), 'from address mismatch', 'transaction', _tx);
+                    tx.from = from;
+                })());
+            }
+            else {
+                tx.from = this.address;
+            }
+            // The JSON-RPC for quai_sendTransaction uses 90000 gas; if the user
+            // wishes to use this, it is easy to specify explicitly, otherwise
+            // we look it up for them.
+            if (tx.gasLimit == null) {
+                promises.push((async () => {
+                    tx.gasLimit = await this.provider.estimateGas({ ...tx, from: this.address });
+                })());
+            }
+            // The address may be an ENS name or Addressable
+            if (tx.to != null) {
+                const _to = tx.to;
+                promises.push((async () => {
+                    tx.to = await resolveAddress(_to);
+                })());
+            }
+        }
+        else {
+            // Make sure the from matches the sender
+            if (tx.outputs) {
+                for (let i = 0; i < tx.outputs.length; i++) {
+                    if (tx.outputs[i].address) {
+                        promises.push((async () => {
+                            const address = await resolveAddress(hexlify(tx.outputs[i].address));
+                            tx.outputs[i].address = getBytes(address);
+                        })());
+                    }
+                }
+            }
+        }
+        // Wait until all of our properties are filled in
+        if (promises.length) {
+            await Promise.all(promises);
+        }
+        const hexTx = this.provider.getRpcTransaction(tx);
+        return this.provider.send('quai_sendTransaction', [hexTx]);
+    }
+    async sendTransaction(tx) {
+        const zone = await this.zoneFromAddress(addressFromTransactionRequest(tx));
+        // This cannot be mined any earlier than any recent block
+        const blockNumber = await this.provider.getBlockNumber(toShard(zone));
+        // Send the transaction
+        const hash = await this.sendUncheckedTransaction(tx);
+        // Unfortunately, JSON-RPC only provides and opaque transaction hash
+        // for a response, and we need the actual transaction, so we poll
+        // for it; it should show up very quickly
+        return await new Promise((resolve, reject) => {
+            const timeouts = [1000, 100];
+            let invalids = 0;
+            const checkTx = async () => {
+                try {
+                    // Try getting the transaction
+                    const tx = await this.provider.getTransaction(hash);
+                    if (tx != null) {
+                        resolve(tx.replaceableTransaction(blockNumber));
+                        return;
+                    }
+                }
+                catch (error) {
+                    // If we were cancelled: stop polling.
+                    // If the data is bad: the node returns bad transactions
+                    // If the network changed: calling again will also fail
+                    // If unsupported: likely destroyed
+                    if (isError(error, 'CANCELLED') ||
+                        isError(error, 'BAD_DATA') ||
+                        isError(error, 'NETWORK_ERROR' )) {
+                        if (error.info == null) {
+                            error.info = {};
+                        }
+                        error.info.sendTransactionHash = hash;
+                        reject(error);
+                        return;
+                    }
+                    // Stop-gap for misbehaving backends; see #4513
+                    if (isError(error, 'INVALID_ARGUMENT')) {
+                        invalids++;
+                        if (error.info == null) {
+                            error.info = {};
+                        }
+                        error.info.sendTransactionHash = hash;
+                        if (invalids > 10) {
+                            reject(error);
+                            return;
+                        }
+                    }
+                    // Notify anyone that cares; but we will try again, since
+                    // it is likely an intermittent service error
+                    this.provider.emit('error', makeError('failed to fetch transation after sending (will try again)', 'UNKNOWN_ERROR', {
+                        error,
+                    }));
+                }
+                // Wait another 4 seconds
+                this.provider._setTimeout(() => {
+                    checkTx();
+                }, timeouts.pop() || 4000);
+            };
+            checkTx();
+        });
+    }
+    async signTransaction(_tx) {
+        const tx = deepCopy(_tx);
+        // QuaiTransactionRequest
+        if ('from' in tx) {
+            if (tx.from) {
+                const from = await resolveAddress(tx.from);
+                assertArgument(from != null && from.toLowerCase() === this.address.toLowerCase(), 'from address mismatch', 'transaction', _tx);
+                tx.from = from;
+            }
+            else {
+                tx.from = this.address;
+            }
+        }
+        else {
+            throw new Error('No QI signing implementation in provider-jsonrpc');
+        }
+        const hexTx = this.provider.getRpcTransaction(tx);
+        return await this.provider.send('quai_signTransaction', [hexTx]);
+    }
+    async signMessage(_message) {
+        const message = typeof _message === 'string' ? toUtf8Bytes(_message) : _message;
+        return await this.provider.send('personal_sign', [hexlify(message), this.address.toLowerCase()]);
+    }
+    async signTypedData(domain, types, _value) {
+        const value = deepCopy(_value);
+        return await this.provider.send('quai_signTypedData_v4', [
+            this.address.toLowerCase(),
+            JSON.stringify(TypedDataEncoder.getPayload(domain, types, value)),
+        ]);
+    }
+    async unlock(password) {
+        return this.provider.send('personal_unlockAccount', [this.address.toLowerCase(), password, null]);
+    }
+    // https://github.com/ethereum/wiki/wiki/JSON-RPC#quai_sign
+    async _legacySignMessage(_message) {
+        const message = typeof _message === 'string' ? toUtf8Bytes(_message) : _message;
+        return await this.provider.send('quai_sign', [this.address.toLowerCase(), hexlify(message)]);
+    }
+}
 /**
  * The JsonRpcApiProvider is an abstract class and **MUST** be sub-classed.
  *
@@ -24600,6 +24797,36 @@ class JsonRpcApiProvider extends AbstractProvider {
         this.#scheduleDrain();
         return promise;
     }
+    async getSigner(address) {
+        if (address == null) {
+            address = 0;
+        }
+        const accountsPromise = this.send('quai_accounts', []);
+        // Account index
+        if (typeof address === 'number') {
+            const accounts = await accountsPromise;
+            if (address >= accounts.length) {
+                throw new Error('no such account');
+            }
+            return new JsonRpcSigner(this, accounts[address]);
+        }
+        const { accounts } = await resolveProperties({
+            network: this.getNetwork(),
+            accounts: accountsPromise,
+        });
+        // Account address
+        address = getAddress(address);
+        for (const account of accounts) {
+            if (getAddress(account) === address) {
+                return new JsonRpcSigner(this, address);
+            }
+        }
+        throw new Error('invalid account');
+    }
+    async listAccounts() {
+        const accounts = await this.send('quai_accounts', []);
+        return accounts.map((a) => new JsonRpcSigner(this, a));
+    }
     destroy() {
         // Stop processing requests
         if (this.#drainTimer) {
@@ -24764,6 +24991,17 @@ class BrowserProvider extends JsonRpcApiProvider {
             }
         };
     }
+    async hasSigner(address) {
+        if (address == null) {
+            address = 0;
+        }
+        const accounts = await this.send('quai_accounts', []);
+        if (typeof address === 'number') {
+            return accounts.length > address;
+        }
+        address = address.toLowerCase();
+        return accounts.filter((a) => a.toLowerCase() === address).length !== 0;
+    }
     async send(method, params) {
         await this._start();
         return await super.send(method, params);
@@ -24797,6 +25035,23 @@ class BrowserProvider extends JsonRpcApiProvider {
         }
         return super.getRpcError(payload, error);
     }
+    async getSigner(address) {
+        if (address == null) {
+            address = 0;
+        }
+        if (!(await this.hasSigner(address))) {
+            try {
+                //const resp =
+                await this.#request('quai_requestAccounts', []);
+                //console.log("RESP", resp);
+            }
+            catch (error) {
+                const payload = error.payload;
+                throw this.getRpcError(payload, { id: payload.id, error });
+            }
+        }
+        return await super.getSigner(address);
+    }
 }
 
 /**
@@ -25319,17 +25574,6 @@ class AbstractSigner {
         // the end for better batching
         return await resolveProperties(pop);
     }
-    async populateQiTransaction(tx) {
-        const pop = {
-            inputsUTXO: tx.inputs,
-            outputsUTXO: tx.outputs,
-            chainId: tx.chainId,
-            type: 2,
-        };
-        //@TOOD: Don't await all over the place; save them up for
-        // the end for better batching
-        return await resolveProperties(pop);
-    }
     async estimateGas(tx) {
         return checkProvider(this, 'estimateGas').estimateGas(await this.populateCall(tx));
     }
@@ -25338,20 +25582,12 @@ class AbstractSigner {
     }
     async sendTransaction(tx) {
         const provider = checkProvider(this, 'sendTransaction');
-        const sender = await this.getAddress();
         const zone = await this.zoneFromAddress(addressFromTransactionRequest(tx));
-        let pop;
-        let txObj;
-        if (isQiAddress(sender)) {
-            pop = await this.populateQiTransaction(tx);
-            txObj = QiTransaction.from(pop);
-        }
-        else {
-            pop = await this.populateQuaiTransaction(tx);
-            txObj = QuaiTransaction.from(pop);
-        }
+        const pop = await this.populateQuaiTransaction(tx);
+        const txObj = QuaiTransaction.from(pop);
+        const sender = await this.getAddress();
         const signedTx = await this.signTransaction(txObj);
-        return await provider.broadcastTransaction(zone, signedTx, 'from' in tx ? tx.from : undefined);
+        return await provider.broadcastTransaction(zone, signedTx, sender);
     }
 }
 /**
@@ -25470,16 +25706,16 @@ class BaseWallet extends AbstractSigner {
             to: tx.to ? resolveAddress(tx.to) : undefined,
             from: tx.from ? resolveAddress(tx.from) : undefined,
         });
-        if (to != null) {
+        if (to !== undefined) {
             validateAddress(to);
             tx.to = to;
         }
-        if (from != null) {
-            validateAddress(from);
-            tx.from = from;
+        if (from !== undefined) {
+            assertArgument(getAddress(from) === this.#address, 'transaction from address mismatch', 'tx.from', from);
         }
-        if (tx.from != null) {
-            assertArgument(getAddress(tx.from) === this.#address, 'transaction from address mismatch', 'tx.from', tx.from);
+        else {
+            // No `from` specified, use the wallet's address
+            tx.from = this.#address;
         }
         const btx = QuaiTransaction.from(tx);
         const digest = keccak256(btx.unsignedSerialized);
@@ -27048,7 +27284,8 @@ class HDNodeVoidWallet extends VoidSigner {
 // Constant to represent the maximum attempt to derive an address
 const MAX_ADDRESS_DERIVATION_ATTEMPTS = 10000000;
 class AbstractHDWallet {
-    static _coinType = 969 ;
+    static _version = 1;
+    static _coinType;
     // Map of account number to HDNodeWallet
     _accounts = new Map();
     // Map of addresses to address info
@@ -27082,7 +27319,7 @@ class AbstractHDWallet {
                 return false;
             }
             const isCorrectShard = addressZone === zone;
-            const isCorrectLedger = (this.coinType() === 969) ? isQiAddress(address) : !isQiAddress(address);
+            const isCorrectLedger = this.coinType() === 969 ? isQiAddress(address) : !isQiAddress(address);
             return isCorrectShard && isCorrectLedger;
         };
         // derive the address node
@@ -27101,7 +27338,11 @@ class AbstractHDWallet {
         } while (!isValidAddressForZone(addressNode.address));
         return addressNode;
     }
-    addAddress(account, addressIndex, zone) {
+    addAddress(account, addressIndex, isChange = false) {
+        return this._addAddress(this._addresses, account, addressIndex, isChange);
+    }
+    // helper method to add an address to the wallet address map
+    _addAddress(addressMap, account, addressIndex, isChange = false) {
         if (!this._accounts.has(account)) {
             this.addAccount(account);
         }
@@ -27111,17 +27352,23 @@ class AbstractHDWallet {
                 throw new Error(`Address for index ${addressIndex} already exists`);
             }
         });
-        const addressNode = this.deriveAddress(account, addressIndex, zone);
-        // create the NeuteredAddressInfo object and update the maps
+        // derive the address node
+        const changeIndex = isChange ? 1 : 0;
+        const addressNode = this._root.deriveChild(account).deriveChild(changeIndex).deriveChild(addressIndex);
+        const zone = getZoneForAddress(addressNode.address);
+        if (!zone) {
+            throw new Error(`Failed to derive a valid address zone for the index ${addressIndex}`);
+        }
+        // create the NeuteredAddressInfo object and update the map
         const neuteredAddressInfo = {
             pubKey: addressNode.publicKey,
             address: addressNode.address,
             account: account,
             index: addressNode.index,
-            change: false,
+            change: isChange,
             zone: zone,
         };
-        this._addresses.set(neuteredAddressInfo.address, neuteredAddressInfo);
+        addressMap.set(neuteredAddressInfo.address, neuteredAddressInfo);
         return neuteredAddressInfo;
     }
     getNextAddress(accountIndex, zone) {
@@ -27170,7 +27417,7 @@ class AbstractHDWallet {
     }
     static createRandom(password, wordlist) {
         if (password == null) {
-            password = "";
+            password = '';
         }
         if (wordlist == null) {
             wordlist = LangEn.wordlist();
@@ -27180,7 +27427,7 @@ class AbstractHDWallet {
     }
     static fromPhrase(phrase, password, wordlist) {
         if (password == null) {
-            password = "";
+            password = '';
         }
         if (wordlist == null) {
             wordlist = LangEn.wordlist();
@@ -27196,29 +27443,76 @@ class AbstractHDWallet {
             throw new Error(`Invalid zone: ${zone}`);
         }
     }
+    // Returns the HD node that derives the address.
+    // If the address is not found in the wallet, an error is thrown.
+    _getHDNodeForAddress(addr) {
+        const addressInfo = this._addresses.get(addr);
+        if (!addressInfo) {
+            throw new Error(`Address ${addr} is not known to this wallet`);
+        }
+        // derive a HD node for the from address using the index
+        const accountNode = this._accounts.get(addressInfo.account);
+        if (!accountNode) {
+            throw new Error(`Account ${addressInfo.account} not found`);
+        }
+        const changeIndex = addressInfo.change ? 1 : 0;
+        const changeNode = accountNode.deriveChild(changeIndex);
+        return changeNode.deriveChild(addressInfo.index);
+    }
+    async serialize() {
+        const addresses = Array.from(this._addresses.values());
+        return {
+            version: this.constructor._version,
+            phrase: this._root.mnemonic.phrase,
+            coinType: this.coinType(),
+            addresses: addresses,
+        };
+    }
+    static async deserialize(serialized) {
+        // validate the version and coinType
+        if (serialized.version !== this._version) {
+            throw new Error(`Invalid version ${serialized.version} for wallet (expected ${this._version})`);
+        }
+        if (serialized.coinType !== this._coinType) {
+            throw new Error(`Invalid coinType ${serialized.coinType} for wallet (expected ${this._coinType})`);
+        }
+        // create the wallet instance
+        const mnemonic = Mnemonic.fromPhrase(serialized.phrase);
+        const path = this.parentPath(serialized.coinType);
+        const root = HDNodeWallet.fromMnemonic(mnemonic, path);
+        const wallet = new this(root);
+        // import the addresses
+        wallet.importSerializedAddresses(wallet._addresses, serialized.addresses);
+        return wallet;
+    }
+    // This method is used to import addresses from a serialized wallet.
+    // It validates the addresses and adds them to the wallet.
+    importSerializedAddresses(addressMap, addresses) {
+        for (const addressInfo of addresses) {
+            const newAddressInfo = this._addAddress(addressMap, addressInfo.account, addressInfo.index, addressInfo.change);
+            // validate the address info
+            if (addressInfo.address !== newAddressInfo.address) {
+                throw new Error(`Address mismatch: ${addressInfo.address} != ${newAddressInfo.address}`);
+            }
+            if (addressInfo.pubKey !== newAddressInfo.pubKey) {
+                throw new Error(`Public key mismatch: ${addressInfo.pubKey} != ${newAddressInfo.pubKey}`);
+            }
+            if (addressInfo.zone !== newAddressInfo.zone) {
+                throw new Error(`Zone mismatch: ${addressInfo.zone} != ${newAddressInfo.zone}`);
+            }
+        }
+    }
 }
 
 class QuaiHDWallet extends AbstractHDWallet {
-    static _cointype = 994;
+    static _version = 1;
+    static _coinType = 994;
     constructor(root, provider) {
         super(root, provider);
     }
-    _getHDNode(from) {
-        const fromAddressInfo = this._addresses.get(from);
-        if (!fromAddressInfo) {
-            throw new Error(`Address ${from} is not known to wallet`);
-        }
-        // derive a HD node for the from address using the index
-        const accountNode = this._accounts.get(fromAddressInfo.account);
-        if (!accountNode) {
-            throw new Error(`Account ${fromAddressInfo.account} not found`);
-        }
-        const changeNode = accountNode.deriveChild(0);
-        return changeNode.deriveChild(fromAddressInfo.index);
-    }
     async signTransaction(tx) {
         const from = await resolveAddress(tx.from);
-        const fromNode = this._getHDNode(from);
+        const fromNode = this._getHDNodeForAddress(from);
         const signedTx = await fromNode.signTransaction(tx);
         return signedTx;
     }
@@ -27227,10 +27521,14 @@ class QuaiHDWallet extends AbstractHDWallet {
             throw new Error('Provider is not set');
         }
         const from = await resolveAddress(tx.from);
-        const fromNode = this._getHDNode(from);
+        const fromNode = this._getHDNodeForAddress(from);
         const fromNodeConnected = fromNode.connect(this.provider);
         return await fromNodeConnected.sendTransaction(tx);
     }
+    async signMessage(address, message) {
+        const addrNode = this._getHDNodeForAddress(address);
+        return await addrNode.signMessage(message);
+    }
 }
 
 /**
@@ -27746,8 +28044,9 @@ function MuSigFactory(ecc) {
 }
 
 class QiHDWallet extends AbstractHDWallet {
+    static _version = 1;
     static _GAP_LIMIT = 20;
-    static _cointype = 969;
+    static _coinType = 969;
     // Map of change addresses to address info
     _changeAddresses = new Map();
     // Array of gap addresses
@@ -27813,7 +28112,7 @@ class QiHDWallet extends AbstractHDWallet {
     }
     async sendTransaction(tx) {
         if (!this.provider) {
-            throw new Error("Provider is not set");
+            throw new Error('Provider is not set');
         }
         if (!tx.inputs || tx.inputs.length === 0) {
             throw new Error('Transaction has no inputs');
@@ -27982,6 +28281,61 @@ class QiHDWallet extends AbstractHDWallet {
         const gapChangeAddresses = this._gapChangeAddresses.filter((addressInfo) => addressInfo.zone === zone);
         return gapChangeAddresses;
     }
+    async signMessage(address, message) {
+        const addrNode = this._getHDNodeForAddress(address);
+        const privKey = addrNode.privateKey;
+        const digest = keccak_256(message);
+        const signature = schnorr.sign(digest, getBytes(privKey));
+        return hexlify(signature);
+    }
+    async serialize() {
+        const hdwalletSerialized = await super.serialize();
+        return {
+            outpoints: this._outpoints,
+            changeAddresses: Array.from(this._changeAddresses.values()),
+            gapAddresses: this._gapAddresses,
+            gapChangeAddresses: this._gapChangeAddresses,
+            ...hdwalletSerialized,
+        };
+    }
+    static async deserialize(serialized) {
+        const wallet = await super.deserialize(serialized);
+        // import the change addresses
+        wallet.importSerializedAddresses(wallet._changeAddresses, serialized.changeAddresses);
+        // import the gap addresses, verifying they exist in the wallet
+        for (const gapAddressInfo of serialized.gapAddresses) {
+            const gapAddress = gapAddressInfo.address;
+            if (!wallet._addresses.has(gapAddress)) {
+                throw new Error(`Address ${gapAddress} not found in wallet`);
+            }
+            wallet._gapAddresses.push(gapAddressInfo);
+        }
+        // import the gap change addresses, verifying they exist in the wallet
+        for (const gapChangeAddressInfo of serialized.gapChangeAddresses) {
+            const gapChangeAddress = gapChangeAddressInfo.address;
+            if (!wallet._changeAddresses.has(gapChangeAddress)) {
+                throw new Error(`Address ${gapChangeAddress} not found in wallet`);
+            }
+            wallet._gapChangeAddresses.push(gapChangeAddressInfo);
+        }
+        // validate the outpoints and import them
+        for (const outpointInfo of serialized.outpoints) {
+            // check the zone is valid
+            wallet.validateZone(outpointInfo.zone);
+            // check the outpoint address is known to the wallet
+            if (!wallet._addresses.has(outpointInfo.address)) {
+                throw new Error(`Address ${outpointInfo.address} not found in wallet`);
+            }
+            const outpoint = outpointInfo.outpoint;
+            // TODO: implement a more robust check for Outpoint
+            // check the Outpoint fields are not empty
+            if (outpoint.Txhash == null || outpoint.Index == null || outpoint.Denomination == null) {
+                throw new Error(`Invalid Outpoint: ${JSON.stringify(outpoint)} `);
+            }
+            wallet._outpoints.push(outpointInfo);
+        }
+        return wallet;
+    }
 }
 
 const Base64 = ')!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_';
@@ -28150,6 +28504,7 @@ var quais = /*#__PURE__*/Object.freeze({
     Interface: Interface,
     JsonRpcApiProvider: JsonRpcApiProvider,
     JsonRpcProvider: JsonRpcProvider,
+    JsonRpcSigner: JsonRpcSigner,
     LangEn: LangEn,
     LangEs: LangEs,
     Log: Log,
@@ -28291,5 +28646,5 @@ var quais = /*#__PURE__*/Object.freeze({
     zeroPadValue: zeroPadValue
 });
 
-export { AbiCoder, AbstractProvider, AbstractSigner, AbstractTransaction, BaseContract, BaseWallet, Block, BrowserProvider, ConstructorFragment, Contract, ContractEventPayload, ContractFactory, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, ErrorDescription, ErrorFragment, EventFragment, EventLog, EventPayload, FallbackFragment, FeeData, FetchCancelSignal, FetchRequest, FetchResponse, FewestCoinSelector, FixedNumber, Fragment, FunctionFragment, HDNodeVoidWallet, Indexed, Interface, JsonRpcApiProvider, JsonRpcProvider, LangEn, LangEs, Log, LogDescription, MaxInt256, MaxUint256, MessagePrefix, MinInt256, Mnemonic, N$1 as N, NamedFragment, Network, ParamType, QiHDWallet, QiTransaction, QuaiHDWallet, QuaiTransaction, Result, Shard, Signature, SigningKey, SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber, SocketProvider, SocketSubscriber, StructFragment, TransactionDescription, TransactionReceipt, Typed, TypedDataEncoder, UndecodedEventLog, UnmanagedSubscriber, Utf8ErrorFuncs, VoidSigner, Wallet, WebSocketProvider, WeiPerEther, Wordlist, WordlistOwl, WordlistOwlA, ZeroAddress, ZeroHash, Zone, accessListify, assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate, checkResultErrors, computeAddress, computeHmac, concat, copyRequest, dataLength, dataSlice, decodeBase58, decodeBase64, decodeBytes32String, decodeProtoTransaction, decodeProtoWorkObject, decryptKeystoreJson, decryptKeystoreJsonSync, defineProperties, encodeBase58, encodeBase64, encodeBytes32String, encodeProtoTransaction, encodeProtoWorkObject, encryptKeystoreJson, encryptKeystoreJsonSync, formatEther, formatMixedCaseChecksumAddress, formatQuai, formatUnits, fromTwos, getAddress, getAddressDetails, getBigInt, getBytes, getBytesCopy, getCreate2Address, getCreateAddress, getNumber, getTxType, getUint, getZoneForAddress, hashMessage, hexlify, id, isAddress, isAddressable, isBytesLike, isCallException, isError, isHexString, isKeystoreJson, isQiAddress, keccak256, lock, makeError, mask, musigCrypto, parseEther, parseQuai, parseUnits, pbkdf2, quais, quaisymbol, randomBytes, recoverAddress, resolveAddress, resolveProperties, ripemd160, scrypt, scryptSync, sha256, sha512, solidityPacked, solidityPackedKeccak256, solidityPackedSha256, stripZerosLeft, toBeArray, toBeHex, toBigInt, toNumber, toQuantity, toTwos, toUtf8Bytes, toUtf8CodePoints, toUtf8String, uuidV4, validateAddress, verifyMessage, verifyTypedData, version, wordlists, zeroPadBytes, zeroPadValue };
+export { AbiCoder, AbstractProvider, AbstractSigner, AbstractTransaction, BaseContract, BaseWallet, Block, BrowserProvider, ConstructorFragment, Contract, ContractEventPayload, ContractFactory, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, ErrorDescription, ErrorFragment, EventFragment, EventLog, EventPayload, FallbackFragment, FeeData, FetchCancelSignal, FetchRequest, FetchResponse, FewestCoinSelector, FixedNumber, Fragment, FunctionFragment, HDNodeVoidWallet, Indexed, Interface, JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, LangEn, LangEs, Log, LogDescription, MaxInt256, MaxUint256, MessagePrefix, MinInt256, Mnemonic, N$1 as N, NamedFragment, Network, ParamType, QiHDWallet, QiTransaction, QuaiHDWallet, QuaiTransaction, Result, Shard, Signature, SigningKey, SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber, SocketProvider, SocketSubscriber, StructFragment, TransactionDescription, TransactionReceipt, Typed, TypedDataEncoder, UndecodedEventLog, UnmanagedSubscriber, Utf8ErrorFuncs, VoidSigner, Wallet, WebSocketProvider, WeiPerEther, Wordlist, WordlistOwl, WordlistOwlA, ZeroAddress, ZeroHash, Zone, accessListify, assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate, checkResultErrors, computeAddress, computeHmac, concat, copyRequest, dataLength, dataSlice, decodeBase58, decodeBase64, decodeBytes32String, decodeProtoTransaction, decodeProtoWorkObject, decryptKeystoreJson, decryptKeystoreJsonSync, defineProperties, encodeBase58, encodeBase64, encodeBytes32String, encodeProtoTransaction, encodeProtoWorkObject, encryptKeystoreJson, encryptKeystoreJsonSync, formatEther, formatMixedCaseChecksumAddress, formatQuai, formatUnits, fromTwos, getAddress, getAddressDetails, getBigInt, getBytes, getBytesCopy, getCreate2Address, getCreateAddress, getNumber, getTxType, getUint, getZoneForAddress, hashMessage, hexlify, id, isAddress, isAddressable, isBytesLike, isCallException, isError, isHexString, isKeystoreJson, isQiAddress, keccak256, lock, makeError, mask, musigCrypto, parseEther, parseQuai, parseUnits, pbkdf2, quais, quaisymbol, randomBytes, recoverAddress, resolveAddress, resolveProperties, ripemd160, scrypt, scryptSync, sha256, sha512, solidityPacked, solidityPackedKeccak256, solidityPackedSha256, stripZerosLeft, toBeArray, toBeHex, toBigInt, toNumber, toQuantity, toTwos, toUtf8Bytes, toUtf8CodePoints, toUtf8String, uuidV4, validateAddress, verifyMessage, verifyTypedData, version, wordlists, zeroPadBytes, zeroPadValue };
 //# sourceMappingURL=quais.js.map