@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigMapAbstraction = void 0;
+const http_utils_1 = require("@taquito/http-utils");
+class BigMapAbstraction {
+    constructor(id, schema, provider) {
+        this.id = id;
+        this.schema = schema;
+        this.provider = provider;
+    }
+    /**
+     *
+     * Fetch one value in a big map
+     *
+     * @param keyToEncode 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
+     *
+     */
+    async get(keyToEncode, block) {
+        try {
+            const id = await this.provider.getBigMapKeyByID(this.id.toString(), keyToEncode, this.schema, block);
+            return id;
+        }
+        catch (e) {
+            if (e instanceof http_utils_1.HttpResponseError && e.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
+                return undefined;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    /**
+     *
+     * 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
+     *
+     */
+    async getMultipleValues(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/taquito/src/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/taquito/src/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/taquito/src/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/taquito/src/contract/contract-methods/contract-method-interface.js

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

package/dist/lib/taquito/src/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");
+/**
+ * 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;
+    }
+    /**
+     * Get the signature of the smart contract method
+     */
+    getSignature() {
+        const generatedSchema = this.parameterSchema.generateSchema();
+        if (this.isAnonymous) {
+            const schemaObj = generatedSchema.schema;
+            return schemaObj?.[this.name];
+        }
+        return generatedSchema;
+    }
+    /**
+     *
+     * Send the smart contract operation
+     *
+     * @param params 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));
+        }
+    }
+    /**
+     *
+     * Create transfer params to be used with TezosToolkit.contract.transfer methods
+     *
+     * @param params 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/taquito/src/contract/contract-methods/contract-on-chain-view.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainView = void 0;
+const utils_1 = require("@taquito/utils");
+const errors_1 = require("../errors");
+const core_1 = require("@taquito/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;
+    }
+    /**
+     * Get the signature of the smart contract view
+     */
+    getSignature() {
+        return {
+            parameter: this._smartContractViewSchema.extractArgsSchema(),
+            result: this._smartContractViewSchema.extractResultSchema(),
+        };
+    }
+    /**
+     * 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.
+     */
+    async executeView(executionContext) {
+        this.verifyContextExecution(executionContext);
+        const chainId = await 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, utils_1.validateAddress)(executionContext.source) !== 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, utils_1.validateAddress)(executionContext.viewCaller) !== 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 core_1.InvalidViewParameterError(this._smartContractViewSchema.viewName, this.getSignature(), this._args, error);
+        }
+    }
+    /**
+     * 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;
+    }
+    async executeViewAndDecodeResult(viewScript) {
+        let storage;
+        try {
+            storage = (await 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/taquito/src/contract/contract.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractAbstraction = exports.ContractView = exports.DEFAULT_SMART_CONTRACT_METHOD_NAME = void 0;
+const michelson_encoder_1 = require("@taquito/michelson-encoder");
+const utils_1 = require("@taquito/utils");
+const contract_method_factory_1 = require("./contract-methods/contract-method-factory");
+const errors_1 = require("./errors");
+const core_1 = require("@taquito/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; } });
+/**
+ * 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;
+    }
+    async read(chainId) {
+        const chainIdValidation = (0, utils_1.validateChain)(chainId ?? '');
+        if ((0, utils_1.validateContractAddress)(chainId ?? '') == utils_1.ValidationResult.VALID) {
+            throw new 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 !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidChainIdError(chainId, chainIdValidation);
+        }
+        const arg = this.parameterSchema.Encode(...this.args);
+        const result = await this.rpc.runView({
+            contract: this.currentContract.address,
+            entrypoint: this.name,
+            input: arg,
+            chain_id: chainId ? chainId : await 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;
+};
+/**
+ * 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;
+        /**
+         * 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 = {};
+        /**
+         * 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 = {};
+        /**
+         * 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 = michelson_encoder_1.Schema.fromRPCResponse({ script: this.script });
+        this.parameterSchema = michelson_encoder_1.ParameterSchema.fromRPCResponse({ script: this.script });
+        this.viewSchema = michelson_encoder_1.ViewSchema.fromRPCResponse({ script: this.script });
+        if (this.viewSchema.length !== 0) {
+            this._initializeOnChainViews(this, rpc, this.readProvider, this.viewSchema);
+        }
+        this.eventSchema = 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 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 michelson_encoder_1.ParameterSchema(entrypointParamWithoutCallback);
+                        const parametersCallback = entrypoints[smartContractMethodName].args[1]
+                            .args[0];
+                        const smartContractMethodCallbackSchema = new 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);
+            };
+        });
+    }
+    /**
+     * Return a friendly representation of the smart contract storage
+     */
+    storage() {
+        return this.storageProvider.getStorage(this.address, this.schema);
+    }
+}
+exports.ContractAbstraction = ContractAbstraction;

package/dist/lib/taquito/src/contract/errors.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidBalanceError = exports.OriginationParameterError = exports.RevealOperationError = exports.InvalidViewSimulationContext = exports.validateAndExtractFailwith = exports.ViewSimulationError = exports.InvalidInitParameter = exports.InvalidCodeParameter = exports.InvalidDelegationSource = exports.InvalidParameterError = void 0;
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates invalid smart contract parameters being passed or used
+ */
+class InvalidParameterError extends core_1.ParameterValidationError {
+    constructor(smartContractMethodName, sigs, invalidParams) {
+        super();
+        this.smartContractMethodName = smartContractMethodName;
+        this.sigs = sigs;
+        this.invalidParams = invalidParams;
+        this.name = 'InvalidParameterError';
+        this.message = `${smartContractMethodName} Received ${invalidParams.length} arguments while expecting one of the following signatures (${JSON.stringify(sigs)})`;
+    }
+}
+exports.InvalidParameterError = InvalidParameterError;
+/**
+ *  @category Error
+ *  Error that indicates an invalid delegation source contract address being passed or used
+ */
+class InvalidDelegationSource extends core_1.ParameterValidationError {
+    constructor(source) {
+        super();
+        this.source = source;
+        this.name = `InvalidDelegationSource`;
+        this.message = `Since Babylon delegation source can no longer be a contract address ${source}. Please use the smart contract abstraction to set your delegate.`;
+    }
+}
+exports.InvalidDelegationSource = InvalidDelegationSource;
+/**
+ *  @category Error
+ *  Error that indicates an invalid smart contract code parameter being passed or used
+ */
+class InvalidCodeParameter extends core_1.ParameterValidationError {
+    constructor(message, data) {
+        super();
+        this.message = message;
+        this.data = data;
+        this.name = 'InvalidCodeParameter';
+    }
+}
+exports.InvalidCodeParameter = InvalidCodeParameter;
+/**
+ *  @category Error
+ *  Error that indicates invalid smart contract init parameter being passed or used
+ */
+class InvalidInitParameter extends core_1.ParameterValidationError {
+    constructor(message, data) {
+        super();
+        this.message = message;
+        this.data = data;
+        this.name = 'InvalidInitParameter';
+    }
+}
+exports.InvalidInitParameter = InvalidInitParameter;
+/**
+ *  @category Error
+ *  Error that indicates a failure when conducting a view simulation
+ */
+class ViewSimulationError extends core_1.RpcError {
+    constructor(message, viewName, failWith, cause) {
+        super();
+        this.message = message;
+        this.viewName = viewName;
+        this.failWith = failWith;
+        this.cause = cause;
+        this.name = 'ViewSimulationError';
+    }
+}
+exports.ViewSimulationError = ViewSimulationError;
+const validateAndExtractFailwith = (error) => {
+    if (isJsonString(error.body)) {
+        const parsedError = JSON.parse(error.body);
+        if (Array.isArray(parsedError) && 'with' in parsedError[parsedError.length - 1]) {
+            return parsedError[parsedError.length - 1].with;
+        }
+    }
+};
+exports.validateAndExtractFailwith = validateAndExtractFailwith;
+const isJsonString = (str) => {
+    try {
+        JSON.parse(str);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+};
+/**
+ *  @category Error
+ *  Error that indicates invalid or unconfigured context when executing a view
+ */
+class InvalidViewSimulationContext extends core_1.ParameterValidationError {
+    constructor(info) {
+        super();
+        this.info = info;
+        this.name = 'InvalidViewSimulationContext';
+        this.message = `${info} Please configure the context of the view execution in the executeView method.`;
+    }
+}
+exports.InvalidViewSimulationContext = InvalidViewSimulationContext;
+/**
+ *  @category Error
+ *  Error that indicates a mistake happening during the reveal operation
+ */
+class RevealOperationError extends core_1.RpcError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'RevealOperationError';
+    }
+}
+exports.RevealOperationError = RevealOperationError;
+/**
+ *  @category Error
+ *  Error that indicates a mistake in the parameters in the preparation of an Origination operation
+ */
+class OriginationParameterError extends core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name;
+    }
+}
+exports.OriginationParameterError = OriginationParameterError;
+/**
+ *  @category Error
+ *  Error that indicates an invalid balance being passed or used
+ */
+class InvalidBalanceError extends core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'InvalidBalanceError';
+    }
+}
+exports.InvalidBalanceError = InvalidBalanceError;

package/dist/lib/taquito/src/contract/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartContractAbstractionSemantic = exports.compose = void 0;
+__exportStar(require("./contract"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./manager-lambda"), exports);
+__exportStar(require("./prepare"), exports);
+__exportStar(require("./view_lambda"), exports);
+var compose_1 = require("./compose");
+Object.defineProperty(exports, "compose", { enumerable: true, get: function () { return compose_1.compose; } });
+__exportStar(require("./contract-methods/contract-method-interface"), exports);
+__exportStar(require("./contract-methods/contract-method-object-param"), exports);
+__exportStar(require("./sapling-state-abstraction"), exports);
+var semantic_1 = require("./semantic");
+Object.defineProperty(exports, "smartContractAbstractionSemantic", { enumerable: true, get: function () { return semantic_1.smartContractAbstractionSemantic; } });

package/dist/lib/taquito/src/contract/interface.js

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