@tezos-x/octez.js 0.9.0

package/dist/lib/context.js

@@ -0,0 +1,182 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.defaultConfigConfirmation = void 0;
+const octez_js_rpc_1 = require("@tezos-x/octez.js-rpc");
+const rpc_injector_1 = require("./injector/rpc-injector");
+const noop_1 = require("./signer/noop");
+const operation_factory_1 = require("./wallet/operation-factory");
+const rpc_tz_provider_1 = require("./tz/rpc-tz-provider");
+const rpc_estimate_provider_1 = require("./estimate/rpc-estimate-provider");
+const rpc_contract_provider_1 = require("./contract/rpc-contract-provider");
+const rpc_batch_provider_1 = require("./batch/rpc-batch-provider");
+const wallet_1 = require("./wallet");
+const michel_codec_parser_1 = require("./parser/michel-codec-parser");
+const rpc_packer_1 = require("./packer/rpc-packer");
+const rxjs_1 = require("rxjs");
+const noop_global_constants_provider_1 = require("./global-constants/noop-global-constants-provider");
+const rpc_read_adapter_1 = require("./read-provider/rpc-read-adapter");
+const polling_subcribe_provider_1 = require("./subscribe/polling-subcribe-provider");
+const octez_js_local_forger_1 = require("./forger/octez.js-local-forger");
+const prepare_provider_1 = require("./prepare/prepare-provider");
+exports.defaultConfigConfirmation = {
+    defaultConfirmationCount: 1,
+    confirmationPollingTimeoutSecond: 180,
+};
+/**
+ * @description Encapsulate common service used throughout different part of the library
+ */
+class Context {
+    constructor(_rpc, _signer = new noop_1.NoopSigner(), _proto, _config = new rxjs_1.BehaviorSubject(Object.assign({}, exports.defaultConfigConfirmation)), forger, injector, packer, wallet, parser, globalConstantsProvider, readProvider, stream) {
+        this._rpc = _rpc;
+        this._signer = _signer;
+        this._proto = _proto;
+        this._config = _config;
+        this.providerDecorator = [];
+        this.tz = new rpc_tz_provider_1.RpcTzProvider(this);
+        this.estimate = new rpc_estimate_provider_1.RPCEstimateProvider(this);
+        this.contract = new rpc_contract_provider_1.RpcContractProvider(this, this.estimate);
+        this.prepare = new prepare_provider_1.PrepareProvider(this);
+        this.batch = new rpc_batch_provider_1.RPCBatchProvider(this, this.estimate);
+        this.wallet = new wallet_1.Wallet(this);
+        /**
+         * @description Applies the decorators on a cloned instance of the context and returned this cloned instance.
+         * The decorators are functions that inject logic into the context.
+         * They are provided by the extensions set on the TezosToolkit by calling the registerProviderDecorator method.
+         */
+        this.withExtensions = () => {
+            let clonedContext = this.clone();
+            this.providerDecorator.forEach((decorator) => {
+                clonedContext = decorator(clonedContext);
+            });
+            return clonedContext;
+        };
+        if (typeof this._rpc === 'string') {
+            this._rpcClient = new octez_js_rpc_1.RpcClient(this._rpc);
+        }
+        else {
+            this._rpcClient = this._rpc;
+        }
+        this._forger = forger ? forger : new octez_js_local_forger_1.TaquitoLocalForger(this);
+        this._injector = injector ? injector : new rpc_injector_1.RpcInjector(this);
+        this.operationFactory = new operation_factory_1.OperationFactory(this);
+        this._walletProvider = wallet ? wallet : new wallet_1.LegacyWalletProvider(this);
+        this._parser = parser ? parser : new michel_codec_parser_1.MichelCodecParser(this);
+        this._packer = packer ? packer : new rpc_packer_1.RpcPacker(this);
+        this._globalConstantsProvider = globalConstantsProvider
+            ? globalConstantsProvider
+            : new noop_global_constants_provider_1.NoopGlobalConstantsProvider();
+        this._readProvider = readProvider ? readProvider : new rpc_read_adapter_1.RpcReadAdapter(this._rpcClient);
+        this._stream = stream ? stream : new polling_subcribe_provider_1.PollingSubscribeProvider(this);
+    }
+    get config() {
+        return this._config.getValue();
+    }
+    set config(value) {
+        this._config.next(Object.assign({}, value));
+    }
+    setPartialConfig(value) {
+        this._config.next(Object.assign(Object.assign({}, this._config.getValue()), value));
+    }
+    get rpc() {
+        return this._rpcClient;
+    }
+    set rpc(value) {
+        this._rpcClient = value;
+    }
+    get injector() {
+        return this._injector;
+    }
+    set injector(value) {
+        this._injector = value;
+    }
+    get forger() {
+        return this._forger;
+    }
+    set forger(value) {
+        this._forger = value;
+    }
+    get signer() {
+        return this._signer;
+    }
+    set signer(value) {
+        this._signer = value;
+    }
+    get walletProvider() {
+        return this._walletProvider;
+    }
+    set walletProvider(value) {
+        this._walletProvider = value;
+    }
+    set proto(value) {
+        this._proto = value;
+    }
+    get proto() {
+        return this._proto;
+    }
+    get parser() {
+        return this._parser;
+    }
+    set parser(value) {
+        this._parser = value;
+    }
+    get packer() {
+        return this._packer;
+    }
+    set packer(value) {
+        this._packer = value;
+    }
+    get globalConstantsProvider() {
+        return this._globalConstantsProvider;
+    }
+    set globalConstantsProvider(value) {
+        this._globalConstantsProvider = value;
+    }
+    get readProvider() {
+        return this._readProvider;
+    }
+    set readProvider(value) {
+        this._readProvider = value;
+    }
+    get stream() {
+        return this._stream;
+    }
+    set stream(value) {
+        this._stream = value;
+    }
+    isAnyProtocolActive() {
+        return __awaiter(this, arguments, void 0, function* (protocol = []) {
+            if (this._proto) {
+                return protocol.includes(this._proto);
+            }
+            else {
+                const next_protocol = yield this.readProvider.getNextProtocol('head');
+                return protocol.includes(next_protocol);
+            }
+        });
+    }
+    isAnySignerConfigured() {
+        return !(this.signer instanceof noop_1.NoopSigner);
+    }
+    /**
+     * @description Create a copy of the current context. Useful when you have long running operation and you do not want a context change to affect the operation
+     */
+    clone() {
+        return new Context(this.rpc, this.signer, this.proto, this._config, this.forger, this._injector, this.packer, this._walletProvider, this._parser, this._globalConstantsProvider, this._readProvider, this._stream);
+    }
+    /**
+     * @description Allows extensions set on the TezosToolkit to inject logic into the context
+     */
+    registerProviderDecorator(fx) {
+        this.providerDecorator.push(fx);
+    }
+}
+exports.Context = Context;

package/dist/lib/contract/big-map.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigMapAbstraction = void 0;
+const octez_js_http_utils_1 = require("@tezos-x/octez.js-http-utils");
+class BigMapAbstraction {
+    constructor(id, schema, provider) {
+        this.id = id;
+        this.schema = schema;
+        this.provider = provider;
+    }
+    /**
+     *
+     * @description Fetch one value in a big map
+     *
+     * @param keysToEncode Key to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from (head will be use by default)
+     * @returns Return a well formatted json object of a big map value or undefined if the key is not found in the big map
+     *
+     */
+    get(keyToEncode, block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const id = yield this.provider.getBigMapKeyByID(this.id.toString(), keyToEncode, this.schema, block);
+                return id;
+            }
+            catch (e) {
+                if (e instanceof octez_js_http_utils_1.HttpResponseError && e.status === octez_js_http_utils_1.STATUS_CODE.NOT_FOUND) {
+                    return undefined;
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+    }
+    /**
+     *
+     * @description Fetch multiple values in a big map
+     * All values will be fetched on the same block level. If a block is specified in the request, the values will be fetched at it.
+     * Otherwise, a first request will be done to the node to fetch the level of the head and all values will be fetched at this level.
+     * If one of the keys does not exist in the big map, its value will be set to undefined.
+     *
+     * @param keysToEncode Array of keys to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from
+     * @param batchSize optional batch size representing the number of requests to execute in parallel
+     * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
+     *
+     */
+    getMultipleValues(keysToEncode_1, block_1) {
+        return __awaiter(this, arguments, void 0, function* (keysToEncode, block, batchSize = 5) {
+            return this.provider.getBigMapKeysByID(this.id.toString(), keysToEncode, this.schema, block, batchSize);
+        });
+    }
+    toJSON() {
+        return this.id.toString();
+    }
+    toString() {
+        return this.id.toString();
+    }
+}
+exports.BigMapAbstraction = BigMapAbstraction;

package/dist/lib/contract/compose.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+function compose(functioncomposer1, functioncomposer2) {
+    return (contractAbstraction, context) => functioncomposer2(functioncomposer1(contractAbstraction, context), context);
+}

package/dist/lib/contract/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SMART_CONTRACT_METHOD_NAME = void 0;
+exports.DEFAULT_SMART_CONTRACT_METHOD_NAME = 'default';

package/dist/lib/contract/contract-methods/contract-method-factory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractMethodFactory = void 0;
+const contract_method_object_param_1 = require("./contract-method-object-param");
+const contract_on_chain_view_1 = require("./contract-on-chain-view");
+class ContractMethodFactory {
+    constructor(provider, contractAddress) {
+        this.provider = provider;
+        this.contractAddress = contractAddress;
+    }
+    createContractMethodObjectParam(smartContractMethodSchema, smartContractMethodName, args, isMultipleEntrypoint = true, isAnonymous = false) {
+        return new contract_method_object_param_1.ContractMethodObject(this.provider, this.contractAddress, smartContractMethodSchema, smartContractMethodName, args, isMultipleEntrypoint, isAnonymous);
+    }
+    createContractViewObjectParam(rpc, readProvider, smartContractViewSchema, contractStorageType, viewArgs) {
+        return new contract_on_chain_view_1.OnChainView(rpc, readProvider, this.contractAddress, smartContractViewSchema, contractStorageType, viewArgs);
+    }
+}
+exports.ContractMethodFactory = ContractMethodFactory;

package/dist/lib/contract/contract-methods/contract-method-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/contract/contract-methods/contract-method-object-param.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractMethodObject = void 0;
+const constants_1 = require("../constants");
+/**
+ * @description Utility class to send smart contract operation
+ * The format for the arguments is the object representation
+ */
+class ContractMethodObject {
+    constructor(provider, address, parameterSchema, name, args = 'unit', isMultipleEntrypoint = true, isAnonymous = false) {
+        this.provider = provider;
+        this.address = address;
+        this.parameterSchema = parameterSchema;
+        this.name = name;
+        this.args = args;
+        this.isMultipleEntrypoint = isMultipleEntrypoint;
+        this.isAnonymous = isAnonymous;
+    }
+    /**
+     * @description Get the signature of the smart contract method
+     */
+    getSignature() {
+        const generatedSchema = this.parameterSchema.generateSchema();
+        if (this.isAnonymous) {
+            const schemaObj = generatedSchema.schema;
+            return schemaObj === null || schemaObj === void 0 ? void 0 : schemaObj[this.name];
+        }
+        return generatedSchema;
+    }
+    /**
+     *
+     * @description Send the smart contract operation
+     *
+     * @param Options generic operation parameter
+     */
+    send(params = {}) {
+        // provider is either ContractProvider | Wallet but pkh method is unique to Wallet
+        if (this.provider && 'pkh' in this.provider) {
+            return this.provider
+                .transfer(this.toTransferParams(params))
+                .send();
+        }
+        else {
+            return this.provider.transfer(this.toTransferParams(params));
+        }
+    }
+    /**
+     *
+     * @description Create transfer params to be used with TezosToolkit.contract.transfer methods
+     *
+     * @param Options generic transfer operation parameters
+     */
+    toTransferParams({ fee, gasLimit, storageLimit, source, amount = 0, mutez = false, } = {}) {
+        const fullTransferParams = {
+            to: this.address,
+            amount,
+            fee,
+            mutez,
+            source,
+            gasLimit,
+            storageLimit,
+            parameter: {
+                entrypoint: this.isMultipleEntrypoint ? this.name : constants_1.DEFAULT_SMART_CONTRACT_METHOD_NAME,
+                value: this.isAnonymous
+                    ? this.parameterSchema.EncodeObject({ [this.name]: this.args })
+                    : this.parameterSchema.EncodeObject(this.args),
+            },
+        };
+        return fullTransferParams;
+    }
+}
+exports.ContractMethodObject = ContractMethodObject;

package/dist/lib/contract/contract-methods/contract-on-chain-view.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainView = void 0;
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const errors_1 = require("../errors");
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+class OnChainView {
+    constructor(_rpc, _readProvider, _contractAddress, _smartContractViewSchema, _contractStorageType, _args = 'Unit') {
+        this._rpc = _rpc;
+        this._readProvider = _readProvider;
+        this._contractAddress = _contractAddress;
+        this._smartContractViewSchema = _smartContractViewSchema;
+        this._contractStorageType = _contractStorageType;
+        this._args = _args;
+    }
+    /**
+     * @description Get the signature of the smart contract view
+     */
+    getSignature() {
+        return {
+            parameter: this._smartContractViewSchema.extractArgsSchema(),
+            result: this._smartContractViewSchema.extractResultSchema(),
+        };
+    }
+    /**
+     * @description Get the result of the view simulation
+     * @param executionContext.source the public key hash of the account who initialized this view execution.
+     * @param executionContext.viewCaller the contract address which is the caller of view.
+     */
+    executeView(executionContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.verifyContextExecution(executionContext);
+            const chainId = yield this._readProvider.getChainId();
+            const viewArgs = this.transformArgsToMichelson();
+            const scriptView = {
+                contract: this._contractAddress,
+                view: this._smartContractViewSchema.viewName,
+                input: viewArgs,
+                chain_id: chainId,
+                source: executionContext.viewCaller,
+            };
+            if (executionContext.source) {
+                scriptView.payer = executionContext.source;
+            }
+            return this.executeViewAndDecodeResult(scriptView);
+        });
+    }
+    verifyContextExecution(executionContext) {
+        if (executionContext.source &&
+            (0, octez_js_utils_1.validateAddress)(executionContext.source) !== octez_js_utils_1.ValidationResult.VALID) {
+            throw new errors_1.InvalidViewSimulationContext(`The source account who initialized the view execution is invalid: ${executionContext.source}.`);
+        }
+        if (!executionContext.viewCaller ||
+            (0, octez_js_utils_1.validateAddress)(executionContext.viewCaller) !== octez_js_utils_1.ValidationResult.VALID) {
+            throw new errors_1.InvalidViewSimulationContext(`The contract which is the caller of view is invalid: ${executionContext.viewCaller}.`);
+        }
+    }
+    transformArgsToMichelson() {
+        try {
+            return this._smartContractViewSchema.encodeViewArgs(this._args);
+        }
+        catch (error) {
+            throw new octez_js_core_1.InvalidViewParameterError(this._smartContractViewSchema.viewName, this.getSignature(), this._args, error);
+        }
+    }
+    /**
+     * @description Loops through the view's instructions and replace BALANCE, SENDER, SELF_ADDRESS and AMOUNT with Michelson expressions that match the current context, if applicable.
+     *
+     * Certain specific instructions have different semantics in view:
+     * BALANCE represents the current amount of mutez held by the contract where view is;
+     * SENDER represents the contract which is the caller of view;
+     * SELF_ADDRESS represents the contract where view is;
+     * AMOUNT is always 0 mutez.
+     *
+     */
+    adaptViewCodeToContext(instructions, viewCaller, contractBalance) {
+        const instructionsToReplace = {
+            BALANCE: [{ prim: 'PUSH', args: [{ prim: 'mutez' }, { int: contractBalance }] }],
+            SENDER: [{ prim: 'PUSH', args: [{ prim: 'address' }, { string: viewCaller }] }],
+            SELF_ADDRESS: [
+                { prim: 'PUSH', args: [{ prim: 'address' }, { string: this._contractAddress }] },
+            ],
+            AMOUNT: [{ prim: 'PUSH', args: [{ prim: 'mutez' }, { int: '0' }] }],
+        };
+        instructions.forEach((inst, i) => {
+            if (inst.prim in instructionsToReplace) {
+                instructions[i] = Object(instructionsToReplace)[inst.prim];
+            }
+            if (inst.args && inst.args.length !== 0) {
+                this.adaptViewCodeToContext(inst.args, viewCaller, contractBalance);
+            }
+            else if (Array.isArray(inst)) {
+                this.adaptViewCodeToContext(inst, viewCaller, contractBalance);
+            }
+        });
+        return instructions;
+    }
+    executeViewAndDecodeResult(viewScript) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let storage;
+            try {
+                storage = (yield this._rpc.runScriptView(viewScript))
+                    .data;
+            }
+            catch (error) {
+                const failWith = (0, errors_1.validateAndExtractFailwith)(error);
+                throw failWith
+                    ? new errors_1.ViewSimulationError(`The simulation of the on-chain view named ${this._smartContractViewSchema.viewName} failed with: ${JSON.stringify(failWith)}`, this._smartContractViewSchema.viewName, failWith, error)
+                    : error;
+            }
+            return this._smartContractViewSchema.decodeViewResult(storage);
+        });
+    }
+}
+exports.OnChainView = OnChainView;

package/dist/lib/contract/contract.js

@@ -0,0 +1,169 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractAbstraction = exports.ContractView = exports.DEFAULT_SMART_CONTRACT_METHOD_NAME = void 0;
+const octez_js_michelson_encoder_1 = require("@tezos-x/octez.js-michelson-encoder");
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const contract_method_factory_1 = require("./contract-methods/contract-method-factory");
+const errors_1 = require("./errors");
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_SMART_CONTRACT_METHOD_NAME", { enumerable: true, get: function () { return constants_1.DEFAULT_SMART_CONTRACT_METHOD_NAME; } });
+/**
+ * @description Utility class to retrieve data from a smart contract's storage without incurring fees via a contract's view method
+ */
+class ContractView {
+    constructor(currentContract, name, callbackParametersSchema, parameterSchema, args, rpc, readProvider) {
+        this.currentContract = currentContract;
+        this.name = name;
+        this.callbackParametersSchema = callbackParametersSchema;
+        this.parameterSchema = parameterSchema;
+        this.args = args;
+        this.rpc = rpc;
+        this.readProvider = readProvider;
+    }
+    read(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chainIdValidation = (0, octez_js_utils_1.validateChain)(chainId !== null && chainId !== void 0 ? chainId : '');
+            if ((0, octez_js_utils_1.validateContractAddress)(chainId !== null && chainId !== void 0 ? chainId : '') == octez_js_utils_1.ValidationResult.VALID) {
+                throw new octez_js_core_1.DeprecationError(`Since version 12, the lambda view no longer depends on a lambda contract. The read method no longer accepts a contract address as a parameter.`);
+            }
+            else if (chainId && chainIdValidation !== octez_js_utils_1.ValidationResult.VALID) {
+                throw new octez_js_core_1.InvalidChainIdError(chainId, chainIdValidation);
+            }
+            const arg = this.parameterSchema.Encode(...this.args);
+            const result = yield this.rpc.runView({
+                contract: this.currentContract.address,
+                entrypoint: this.name,
+                input: arg,
+                chain_id: chainId ? chainId : yield this.readProvider.getChainId(),
+            });
+            return this.callbackParametersSchema.Execute(result.data);
+        });
+    }
+}
+exports.ContractView = ContractView;
+const validateArgs = (args, schema, name) => {
+    const sigs = schema.ExtractSignatures();
+    if (!sigs.find((x) => x.length === args.length)) {
+        throw new errors_1.InvalidParameterError(name, sigs, args);
+    }
+};
+// lambda view tzip4
+const isView = (entrypoint) => {
+    let isView = false;
+    if ('prim' in entrypoint && entrypoint.prim === 'pair' && entrypoint.args) {
+        const lastElement = entrypoint.args[entrypoint.args.length - 1];
+        if ('prim' in lastElement && lastElement.prim === 'contract') {
+            isView = true;
+        }
+    }
+    return isView;
+};
+/**
+ * @description Smart contract abstraction
+ */
+class ContractAbstraction {
+    constructor(address, script, provider, storageProvider, entrypoints, rpc, readProvider) {
+        this.address = address;
+        this.script = script;
+        this.storageProvider = storageProvider;
+        this.entrypoints = entrypoints;
+        this.rpc = rpc;
+        this.readProvider = readProvider;
+        /**
+         * @description Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
+         * `methodsObject` serves the exact same purpose as the `methods` member. The difference is that it allows passing the parameter in an object format when calling the smart contract method (instead of the flattened representation)
+         * NB: if the contract contains annotation it will include named properties; if not it will be indexed by a number.
+         *
+         */
+        this.methodsObject = {};
+        /**
+         * @description Contains lamda views (tzip4) that are implemented by the target Tezos Smart Contract, and offers the user to call the lambda views as if they were native TS/JS methods.
+         * NB: These are the view defined in the tzip4 standard, not the views introduced by the Hangzhou protocol.
+         */
+        this.views = {};
+        /**
+         * @description Contains on-chain views that are defined by the target Tezos Smart Contract, and offers the user to simulate the views execution as if they were native TS/JS methods.
+         * NB: the expected format for the parameter when calling a smart contract view is the object format (same format as for the storage) and not the flattened representation.
+         *
+         */
+        this.contractViews = {};
+        this.contractMethodFactory = new contract_method_factory_1.ContractMethodFactory(provider, address);
+        this.schema = octez_js_michelson_encoder_1.Schema.fromRPCResponse({ script: this.script });
+        this.parameterSchema = octez_js_michelson_encoder_1.ParameterSchema.fromRPCResponse({ script: this.script });
+        this.viewSchema = octez_js_michelson_encoder_1.ViewSchema.fromRPCResponse({ script: this.script });
+        if (this.viewSchema.length !== 0) {
+            this._initializeOnChainViews(this, rpc, this.readProvider, this.viewSchema);
+        }
+        this.eventSchema = octez_js_michelson_encoder_1.EventSchema.fromRPCResponse({ script: this.script });
+        this._initializeMethods(this, this.entrypoints.entrypoints, this.rpc, this.readProvider);
+    }
+    _initializeMethods(currentContract, entrypoints, rpc, readProvider) {
+        const parameterSchema = this.parameterSchema;
+        const keys = Object.keys(entrypoints);
+        if (parameterSchema.isMultipleEntryPoint) {
+            keys.forEach((smartContractMethodName) => {
+                const smartContractMethodSchema = new octez_js_michelson_encoder_1.ParameterSchema(entrypoints[smartContractMethodName]);
+                this.methodsObject[smartContractMethodName] = function (args) {
+                    return currentContract.contractMethodFactory.createContractMethodObjectParam(smartContractMethodSchema, smartContractMethodName, args);
+                };
+                if (isView(entrypoints[smartContractMethodName])) {
+                    const view = function (...args) {
+                        const entrypointParamWithoutCallback = entrypoints[smartContractMethodName]
+                            .args[0];
+                        const smartContractMethodSchemaWithoutCallback = new octez_js_michelson_encoder_1.ParameterSchema(entrypointParamWithoutCallback);
+                        const parametersCallback = entrypoints[smartContractMethodName].args[1]
+                            .args[0];
+                        const smartContractMethodCallbackSchema = new octez_js_michelson_encoder_1.ParameterSchema(parametersCallback);
+                        validateArgs(args, smartContractMethodSchemaWithoutCallback, smartContractMethodName);
+                        return new ContractView(currentContract, smartContractMethodName, smartContractMethodCallbackSchema, smartContractMethodSchemaWithoutCallback, args, rpc, readProvider);
+                    };
+                    this.views[smartContractMethodName] = view;
+                }
+            });
+            // Deal with methods with no annotations which were not discovered by the RPC endpoint
+            // Methods with no annotations are discovered using parameter schema
+            const generatedSchema = parameterSchema.generateSchema();
+            const schemaKeys = generatedSchema.schema && typeof generatedSchema.schema === 'object'
+                ? Object.keys(generatedSchema.schema)
+                : [];
+            const anonymousMethods = schemaKeys.filter((key) => Object.keys(entrypoints).indexOf(key) === -1);
+            anonymousMethods.forEach((smartContractMethodName) => {
+                this.methodsObject[smartContractMethodName] = function (args) {
+                    return currentContract.contractMethodFactory.createContractMethodObjectParam(parameterSchema, smartContractMethodName, args, false, true);
+                };
+            });
+        }
+        else {
+            const smartContractMethodSchema = this.parameterSchema;
+            this.methodsObject[constants_1.DEFAULT_SMART_CONTRACT_METHOD_NAME] =
+                function (args) {
+                    return currentContract.contractMethodFactory.createContractMethodObjectParam(smartContractMethodSchema, constants_1.DEFAULT_SMART_CONTRACT_METHOD_NAME, args, false);
+                };
+        }
+    }
+    _initializeOnChainViews(currentContract, rpc, readProvider, allContractViews) {
+        const storageType = this.schema.val;
+        allContractViews.forEach((viewSchema) => {
+            this.contractViews[viewSchema.viewName] = function (args) {
+                return currentContract.contractMethodFactory.createContractViewObjectParam(rpc, readProvider, viewSchema, storageType, args);
+            };
+        });
+    }
+    /**
+     * @description Return a friendly representation of the smart contract storage
+     */
+    storage() {
+        return this.storageProvider.getStorage(this.address, this.schema);
+    }
+}
+exports.ContractAbstraction = ContractAbstraction;