Vue.js TypeError: Cannot read private member from an object whose class did not declare it

[d0rich]

I'm getting following error, when I am using get methods in the contracts in Vue.js app:

Uncaught (in promise) TypeError: Cannot read private member from an object whose class did not declare it
    at __classPrivateFieldGet (TonClient.js:17:94)
    at Proxy.runMethod (TonClient.js:53:25)
    at Proxy.callGetMethod (TonClient.js:68:21)
    at Object.get (TonClient.js:329:39)
    at DSocialNetworkMaster.getGetBlogsCount (tact_DSocialNetworkMaster.ts:1750:38)
    at Proxy.<anonymous> (openContract.js:38:47)
    at getLastBlogAddress (CreateBlog.vue:87:52)
    at goToNewBlogAddress (CreateBlog.vue:72:25)
    at callWithErrorHandling (runtime-core.esm-bundler.js:158:18)
    at callWithAsyncErrorHandling (runtime-core.esm-bundler.js:166:17)

Possibly, it also can be the case in other frameworks, but as far as I know Vue and JS private hash fields (TonClient.#api) have difficult relationships because of Proxies used by Vue. It might resolve the error, if we replace all hash fields with just private TS properties.

[d0rich]

Update: Yep, I have tried to replace private hash methods outputs with public ones in the package, and problem was resolved.

Please, delete private hash fields from classes. I also can do that for you.

Changed JS file

"use strict";
/**
 * Copyright (c) Whales Corp.
 * All Rights Reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
var _TonClient_api;
Object.defineProperty(exports, "__esModule", { value: true });
exports.TonClient = void 0;
const HttpApi_1 = require("./api/HttpApi");
const ton_core_1 = require("@ton/core");
class TonClient {
    constructor(parameters) {
        this.parameters = {
            endpoint: parameters.endpoint
        };
        this.api = new HttpApi_1.HttpApi(this.parameters.endpoint, {
          timeout: parameters.timeout,
          apiKey: parameters.apiKey,
          adapter: parameters.httpAdapter
        });
    }
    /**
     * Get Address Balance
     * @param address address for balance check
     * @returns balance
     */
    async getBalance(address) {
        return (await this.getContractState(address)).balance;
    }
    /**
     * Invoke get method
     * @param address contract address
     * @param name name of method
     * @param params optional parameters
     * @returns stack and gas_used field
     */
    async runMethod(address, name, stack = []) {
        let res = await this.api.callGetMethod(address, name, stack);
        if (res.exit_code !== 0) {
            throw Error('Unable to execute get method. Got exit_code: ' + res.exit_code);
        }
        return { gas_used: res.gas_used, stack: parseStack(res.stack) };
    }
    /**
     * Invoke get method
     * @param address contract address
     * @param name name of method
     * @param params optional parameters
     * @returns stack and gas_used field
     * @deprecated use runMethod instead
     */
    async callGetMethod(address, name, stack = []) {
        return this.runMethod(address, name, stack);
    }
    /**
     * Invoke get method that returns error code instead of throwing error
     * @param address contract address
     * @param name name of method
     * @param params optional parameters
     * @returns stack and gas_used field
    */
    async runMethodWithError(address, name, params = []) {
        let res = await this.api.callGetMethod(address, name, params);
        return { gas_used: res.gas_used, stack: parseStack(res.stack), exit_code: res.exit_code };
    }
    /**
     * Invoke get method that returns error code instead of throwing error
     * @param address contract address
     * @param name name of method
     * @param params optional parameters
     * @returns stack and gas_used field
     * @deprecated use runMethodWithError instead
     */
    async callGetMethodWithError(address, name, stack = []) {
        return this.runMethodWithError(address, name, stack);
    }
    /**
     * Get transactions
     * @param address address
     */
    async getTransactions(address, opts) {
        // Fetch transactions
        let tx = await this.api.getTransactions(address, opts);
        let res = [];
        for (let r of tx) {
            res.push((0, ton_core_1.loadTransaction)(ton_core_1.Cell.fromBoc(Buffer.from(r.data, 'base64'))[0].beginParse()));
        }
        return res;
    }
    /**
     * Get transaction by it's id
     * @param address address
     * @param lt logical time
     * @param hash transaction hash
     * @returns transaction or null if not exist
     */
    async getTransaction(address, lt, hash) {
        let res = await this.api.getTransaction(address, lt, hash);
        if (res) {
            return (0, ton_core_1.loadTransaction)(ton_core_1.Cell.fromBoc(Buffer.from(res.data, 'base64'))[0].beginParse());
        }
        else {
            return null;
        }
    }
    /**
     * Fetch latest masterchain info
     * @returns masterchain info
     */
    async getMasterchainInfo() {
        let r = await this.api.getMasterchainInfo();
        return {
            workchain: r.init.workchain,
            shard: r.last.shard,
            initSeqno: r.init.seqno,
            latestSeqno: r.last.seqno
        };
    }
    /**
     * Fetch latest workchain shards
     * @param seqno masterchain seqno
     */
    async getWorkchainShards(seqno) {
        let r = await this.api.getShards(seqno);
        return r.map((m) => ({
            workchain: m.workchain,
            shard: m.shard,
            seqno: m.seqno
        }));
    }
    /**
     * Fetch transactions inf shards
     * @param workchain
     * @param seqno
     * @param shard
     */
    async getShardTransactions(workchain, seqno, shard) {
        let tx = await this.api.getBlockTransactions(workchain, seqno, shard);
        if (tx.incomplete) {
            throw Error('Unsupported');
        }
        return tx.transactions.map((v) => ({
            account: ton_core_1.Address.parseRaw(v.account),
            lt: v.lt,
            hash: v.hash
        }));
    }
    /**
     * Send message to a network
     * @param src source message
     */
    async sendMessage(src) {
        const boc = (0, ton_core_1.beginCell)()
            .store((0, ton_core_1.storeMessage)(src))
            .endCell()
            .toBoc();
        await this.api.sendBoc(boc);
    }
    /**
     * Send file to a network
     * @param src source file
     */
    async sendFile(src) {
        await this.api.sendBoc(src);
    }
    /**
     * Estimate fees for external message
     * @param address target address
     * @returns
     */
    async estimateExternalMessageFee(address, args) {
        return await this.api.estimateFee(address, { body: args.body, initCode: args.initCode, initData: args.initData, ignoreSignature: args.ignoreSignature });
    }
    /**
     * Send external message to contract
     * @param contract contract to send message
     * @param src message body
     */
    async sendExternalMessage(contract, src) {
        if (await this.isContractDeployed(contract.address) || !contract.init) {
            const message = (0, ton_core_1.external)({
                to: contract.address,
                body: src
            });
            await this.sendMessage(message);
        }
        else {
            const message = (0, ton_core_1.external)({
                to: contract.address,
                init: { code: contract.init.code, data: contract.init.data },
                body: src
            });
            await this.sendMessage(message);
        }
    }
    /**
     * Check if contract is deployed
     * @param address addres to check
     * @returns true if contract is in active state
     */
    async isContractDeployed(address) {
        return (await this.getContractState(address)).state === 'active';
    }
    /**
     * Resolves contract state
     * @param address contract address
     */
    async getContractState(address) {
        let info = await this.api.getAddressInformation(address);
        let balance = BigInt(info.balance);
        let state = info.state;
        return {
            balance,
            state,
            code: info.code !== '' ? Buffer.from(info.code, 'base64') : null,
            data: info.data !== '' ? Buffer.from(info.data, 'base64') : null,
            lastTransaction: info.last_transaction_id.lt !== '0' ? {
                lt: info.last_transaction_id.lt,
                hash: info.last_transaction_id.hash,
            } : null,
            blockId: {
                workchain: info.block_id.workchain,
                shard: info.block_id.shard,
                seqno: info.block_id.seqno
            },
            timestampt: info.sync_utime
        };
    }
    /**
     * Open contract
     * @param src source contract
     * @returns contract
     */
    open(src) {
        return (0, ton_core_1.openContract)(src, (args) => createProvider(this, args.address, args.init));
    }
    /**
     * Create a provider
     * @param address address
     * @param init optional init
     * @returns provider
     */
    provider(address, init) {
        return createProvider(this, address, init);
    }
}
exports.TonClient = TonClient;
_TonClient_api = new WeakMap();
function parseStack(src) {
    let stack = [];
    for (let s of src) {
        if (s[0] === 'num') {
            let val = s[1];
            if (val.startsWith('-')) {
                stack.push({ type: 'int', value: -BigInt(val.slice(1)) });
            }
            else {
                stack.push({ type: 'int', value: BigInt(val) });
            }
        }
        else if (s[0] === 'null') {
            stack.push({ type: 'null' });
        }
        else if (s[0] === 'cell') {
            stack.push({ type: 'cell', cell: ton_core_1.Cell.fromBoc(Buffer.from(s[1].bytes, 'base64'))[0] });
        }
        else if (s[0] === 'slice') {
            stack.push({ type: 'slice', cell: ton_core_1.Cell.fromBoc(Buffer.from(s[1].bytes, 'base64'))[0] });
        }
        else if (s[0] === 'builder') {
            stack.push({ type: 'builder', cell: ton_core_1.Cell.fromBoc(Buffer.from(s[1].bytes, 'base64'))[0] });
        }
        else {
            throw Error('Unsupported stack item type: ' + s[0]);
        }
    }
    return new ton_core_1.TupleReader(stack);
}
function createProvider(client, address, init) {
    return {
        async getState() {
            let state = await client.getContractState(address);
            let balance = state.balance;
            let last = state.lastTransaction ? { lt: BigInt(state.lastTransaction.lt), hash: Buffer.from(state.lastTransaction.hash, 'base64') } : null;
            let storage;
            if (state.state === 'active') {
                storage = {
                    type: 'active',
                    code: state.code ? state.code : null,
                    data: state.data ? state.data : null,
                };
            }
            else if (state.state === 'uninitialized') {
                storage = {
                    type: 'uninit',
                };
            }
            else if (state.state === 'frozen') {
                storage = {
                    type: 'frozen',
                    stateHash: Buffer.alloc(0),
                };
            }
            else {
                throw Error('Unsupported state');
            }
            return {
                balance,
                last,
                state: storage,
            };
        },
        async get(name, args) {
            let method = await client.callGetMethod(address, name, args);
            return { stack: method.stack };
        },
        async external(message) {
            //
            // Resolve init
            //
            let neededInit = null;
            if (init && !await client.isContractDeployed(address)) {
                neededInit = init;
            }
            //
            // Send package
            //
            const ext = (0, ton_core_1.external)({
                to: address,
                init: neededInit ? { code: neededInit.code, data: neededInit.data } : null,
                body: message
            });
            let boc = (0, ton_core_1.beginCell)()
                .store((0, ton_core_1.storeMessage)(ext))
                .endCell()
                .toBoc();
            await client.sendFile(boc);
        },
        async internal(via, message) {
            // Resolve init
            let neededInit = null;
            if (init && (!await client.isContractDeployed(address))) {
                neededInit = init;
            }
            // Resolve bounce
            let bounce = true;
            if (message.bounce !== null && message.bounce !== undefined) {
                bounce = message.bounce;
            }
            // Resolve value
            let value;
            if (typeof message.value === 'string') {
                value = (0, ton_core_1.toNano)(message.value);
            }
            else {
                value = message.value;
            }
            // Resolve body
            let body = null;
            if (typeof message.body === 'string') {
                body = (0, ton_core_1.comment)(message.body);
            }
            else if (message.body) {
                body = message.body;
            }
            // Send internal message
            await via.send({
                to: address,
                value,
                bounce,
                sendMode: message.sendMode,
                init: neededInit,
                body
            });
        }
    };
}