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

package/dist/lib/taquito/src/operations/transaction-operation.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionOperation = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const errors_1 = require("./errors");
+const operations_1 = require("./operations");
+/**
+ * Transaction operation provides utility functions to fetch a newly issued transaction
+ *
+ * @remarks Currently supports one transaction per operation
+ */
+class TransactionOperation extends operations_1.Operation {
+    constructor(hash, params, source, raw, results, context) {
+        super(hash, raw, results, context);
+        this.params = params;
+        this.source = source;
+    }
+    get operationResults() {
+        const transactionOp = Array.isArray(this.results) &&
+            this.results.find((op) => op.kind === 'transaction');
+        return transactionOp ? [transactionOp] : [];
+    }
+    get status() {
+        const operationResults = this.operationResults;
+        const txResult = operationResults[0];
+        if (txResult) {
+            return txResult.metadata.operation_result.status;
+        }
+        else {
+            return 'unknown';
+        }
+    }
+    get amount() {
+        return new bignumber_js_1.default(this.params.amount);
+    }
+    get destination() {
+        return this.params.destination;
+    }
+    get fee() {
+        return Number(this.params.fee);
+    }
+    get gasLimit() {
+        return Number(this.params.gas_limit);
+    }
+    get storageLimit() {
+        return Number(this.params.storage_limit);
+    }
+    sumProp(arr, prop) {
+        return arr.reduce((prev, current) => {
+            return prop in current ? Number(current[prop]) + prev : prev;
+        }, 0);
+    }
+    get consumedGas() {
+        bignumber_js_1.default.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: bignumber_js_1.default.ROUND_UP });
+        return new bignumber_js_1.default(this.consumedMilliGas).dividedBy(1000).toString();
+    }
+    get consumedMilliGas() {
+        return String(this.sumProp((0, errors_1.flattenOperationResult)({ contents: this.operationResults }), 'consumed_milligas'));
+    }
+    get storageDiff() {
+        return String(this.sumProp((0, errors_1.flattenOperationResult)({ contents: this.operationResults }), 'paid_storage_size_diff'));
+    }
+    get storageSize() {
+        return String(this.sumProp((0, errors_1.flattenOperationResult)({ contents: this.operationResults }), 'storage_size'));
+    }
+    get errors() {
+        return (0, errors_1.flattenErrors)({ contents: this.operationResults });
+    }
+}
+exports.TransactionOperation = TransactionOperation;

package/dist/lib/taquito/src/operations/transfer-ticket-operation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferTicketOperation = void 0;
+const rpc_1 = require("@taquito/rpc");
+const bignumber_js_1 = require("bignumber.js");
+const operations_1 = require("./operations");
+/**
+ *
+ * Transfer tickets from a Tezos address (tz1, tz2 or tz3) to a smart contract address (KT1) (everything on layer 1 at this step)
+ *
+ * @remarks Currently only supports one L2 ticket holder transfer at once. ie. one collection of tickets owned by tz1, tz2 or tz3 to a smart contract.
+ */
+class TransferTicketOperation extends operations_1.Operation {
+    constructor(hash, params, source, raw, results, context) {
+        super(hash, raw, results, context);
+        this.params = params;
+        this.source = source;
+    }
+    get operationResults() {
+        const transferOp = Array.isArray(this.results) &&
+            this.results.find((op) => op.kind === rpc_1.OpKind.TRANSFER_TICKET);
+        const result = transferOp && transferOp.metadata && transferOp.metadata.operation_result;
+        return result ? result : undefined;
+    }
+    get status() {
+        return this.operationResults?.status ?? 'unknown';
+    }
+    get fee() {
+        return Number(this.params.fee);
+    }
+    get gasLimit() {
+        return Number(this.params.gas_limit);
+    }
+    get storageLimit() {
+        return Number(this.params.storage_limit);
+    }
+    get consumedGas() {
+        bignumber_js_1.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: bignumber_js_1.BigNumber.ROUND_UP });
+        return this.consumedMilliGas
+            ? new bignumber_js_1.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
+            : undefined;
+    }
+    get consumedMilliGas() {
+        return this.operationResults?.consumed_milligas;
+    }
+}
+exports.TransferTicketOperation = TransferTicketOperation;

package/dist/lib/taquito/src/operations/types.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMetadataWithInternalOperationResult = exports.hasMetadataWithResult = exports.hasMetadata = exports.isSourceOp = exports.isOpRequireReveal = exports.isOpWithFee = exports.isOpWithGasBuffer = exports.isKind = exports.findWithKind = exports.attachKind = exports.OpKind = void 0;
+const rpc_1 = require("@taquito/rpc");
+var rpc_2 = require("@taquito/rpc");
+Object.defineProperty(exports, "OpKind", { enumerable: true, get: function () { return rpc_2.OpKind; } });
+const attachKind = (op, kind) => {
+    return { ...op, kind };
+};
+exports.attachKind = attachKind;
+const findWithKind = (arr, kind) => {
+    if (Array.isArray(arr)) {
+        const found = arr.find((op) => op.kind === kind);
+        if (found && (0, exports.isKind)(found, kind)) {
+            return found;
+        }
+    }
+};
+exports.findWithKind = findWithKind;
+const isKind = (op, kind) => {
+    return op.kind === kind;
+};
+exports.isKind = isKind;
+const feeConsumingOpKinds = [
+    rpc_1.OpKind.TRANSACTION,
+    rpc_1.OpKind.DELEGATION,
+    rpc_1.OpKind.ORIGINATION,
+    rpc_1.OpKind.REVEAL,
+    rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT,
+    rpc_1.OpKind.INCREASE_PAID_STORAGE,
+    rpc_1.OpKind.TRANSFER_TICKET,
+    rpc_1.OpKind.UPDATE_CONSENSUS_KEY,
+    rpc_1.OpKind.UPDATE_COMPANION_KEY,
+    rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES,
+    rpc_1.OpKind.SMART_ROLLUP_ORIGINATE,
+    rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE,
+];
+const isOpWithGasBuffer = (op) => {
+    if (op.kind === rpc_1.OpKind.TRANSACTION && op.destination?.startsWith('KT1')) {
+        return true;
+    }
+    else {
+        return ([
+            'origination',
+            'register_global_constant',
+            'transfer_ticket',
+            'update_consensus_key',
+            'update_companion_key',
+            'smart_rollup_add_messages',
+            'smart_rollup_originate',
+        ].indexOf(op.kind) !== -1);
+    }
+};
+exports.isOpWithGasBuffer = isOpWithGasBuffer;
+const isOpWithFee = (op) => feeConsumingOpKinds.includes(op.kind);
+exports.isOpWithFee = isOpWithFee;
+const isOpRequireReveal = (op) => {
+    return ([
+        'transaction',
+        'delegation',
+        'origination',
+        'register_global_constant',
+        'increase_paid_storage',
+        'transfer_ticket',
+        'update_consensus_key',
+        'update_companion_key',
+        'smart_rollup_add_messages',
+        'smart_rollup_originate',
+        'smart_rollup_execute_outbox_message',
+    ].indexOf(op.kind) !== -1);
+};
+exports.isOpRequireReveal = isOpRequireReveal;
+const isSourceOp = (op) => {
+    return ['transaction', 'delegation', 'origination', 'reveal', 'ballot'].indexOf(op.kind) !== -1;
+};
+exports.isSourceOp = isSourceOp;
+const hasMetadata = (op) => {
+    return 'metadata' in op;
+};
+exports.hasMetadata = hasMetadata;
+const hasMetadataWithResult = (op) => {
+    return (0, exports.hasMetadata)(op) && 'operation_result' in op.metadata;
+};
+exports.hasMetadataWithResult = hasMetadataWithResult;
+const hasMetadataWithInternalOperationResult = (op) => {
+    return (0, exports.hasMetadata)(op) && 'internal_operation_results' in op.metadata;
+};
+exports.hasMetadataWithInternalOperationResult = hasMetadataWithInternalOperationResult;

package/dist/lib/taquito/src/operations/update-companion-key-operation.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCompanionKeyOperation = void 0;
+const core_1 = require("@taquito/core");
+const operations_1 = require("./operations");
+/**
+ *
+ * UpdateCompanionKeyOperation provides utility to fetch properties for Operation of kind UpdateCompanionKey
+ *
+ */
+class UpdateCompanionKeyOperation extends operations_1.Operation {
+    constructor(hash, params, source, raw, results, context) {
+        super(hash, raw, results, context);
+        this.params = params;
+        this.source = source;
+    }
+    get operationResults() {
+        const updateCompanionKeyOp = Array.isArray(this.results) &&
+            this.results.find((op) => op.kind === 'update_companion_key');
+        const result = updateCompanionKeyOp &&
+            updateCompanionKeyOp.metadata &&
+            updateCompanionKeyOp.metadata.operation_result;
+        return result ? result : undefined;
+    }
+    get status() {
+        return this.operationResults?.status ?? 'unknown';
+    }
+    get fee() {
+        return Number(this.params.fee);
+    }
+    get gasLimit() {
+        return Number(this.params.gas_limit);
+    }
+    get storageLimit() {
+        return Number(this.params.storage_limit);
+    }
+    get pk() {
+        return this.params.pk;
+    }
+    get proof() {
+        if (this.params.proof) {
+            return this.params.proof;
+        }
+        else {
+            throw new core_1.ProhibitedActionError('Only updating companion key to a BLS account has proof');
+        }
+    }
+    get consumedMilliGas() {
+        return this.operationResults?.consumed_milligas;
+    }
+    get errors() {
+        return this.operationResults?.errors;
+    }
+}
+exports.UpdateCompanionKeyOperation = UpdateCompanionKeyOperation;

package/dist/lib/taquito/src/operations/update-consensus-key-operation.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateConsensusKeyOperation = void 0;
+const core_1 = require("@taquito/core");
+const operations_1 = require("./operations");
+/**
+ *
+ * UpdateConsensusKeyOperation provides utility to fetch properties for Operation of kind UpdateConsensusKey
+ *
+ */
+class UpdateConsensusKeyOperation extends operations_1.Operation {
+    constructor(hash, params, source, raw, results, context) {
+        super(hash, raw, results, context);
+        this.params = params;
+        this.source = source;
+    }
+    get operationResults() {
+        const updateConsensusKeyOp = Array.isArray(this.results) &&
+            this.results.find((op) => op.kind === 'update_consensus_key');
+        const result = updateConsensusKeyOp &&
+            updateConsensusKeyOp.metadata &&
+            updateConsensusKeyOp.metadata.operation_result;
+        return result ? result : undefined;
+    }
+    get status() {
+        return this.operationResults?.status ?? 'unknown';
+    }
+    get fee() {
+        return Number(this.params.fee);
+    }
+    get gasLimit() {
+        return Number(this.params.gas_limit);
+    }
+    get storageLimit() {
+        return Number(this.params.storage_limit);
+    }
+    get pk() {
+        return this.params.pk;
+    }
+    get proof() {
+        if (this.params.proof) {
+            return this.params.proof;
+        }
+        else {
+            throw new core_1.ProhibitedActionError('Only updating consensus key to a BLS account has proof');
+        }
+    }
+    get consumedMilliGas() {
+        return this.operationResults?.consumed_milligas;
+    }
+    get errors() {
+        return this.operationResults?.errors;
+    }
+}
+exports.UpdateConsensusKeyOperation = UpdateConsensusKeyOperation;

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

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

package/dist/lib/taquito/src/packer/michel-codec-packer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelCodecPacker = void 0;
+const michel_codec_1 = require("@taquito/michel-codec");
+class MichelCodecPacker {
+    async packData(data) {
+        const { bytes } = (0, michel_codec_1.packDataBytes)(data.data, data.type);
+        return { packed: bytes };
+    }
+}
+exports.MichelCodecPacker = MichelCodecPacker;

package/dist/lib/taquito/src/packer/rpc-packer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcPacker = void 0;
+class RpcPacker {
+    constructor(context) {
+        this.context = context;
+    }
+    async packData(data) {
+        return this.context.rpc.packData(data);
+    }
+}
+exports.RpcPacker = RpcPacker;

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

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

package/dist/lib/taquito/src/parser/michel-codec-parser.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelCodecParser = void 0;
+const michel_codec_1 = require("@taquito/michel-codec");
+const errors_1 = require("../contract/errors");
+const michelson_encoder_1 = require("@taquito/michelson-encoder");
+class MichelCodecParser {
+    constructor(context) {
+        this.context = context;
+    }
+    async getNextProto() {
+        if (!this.context.proto) {
+            const nextProto = await this.context.readProvider.getNextProtocol('head');
+            this.context.proto = nextProto;
+        }
+        return this.context.proto;
+    }
+    async parseScript(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseScript(src);
+    }
+    async parseMichelineExpression(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseMichelineExpression(src);
+    }
+    async parseJSON(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseJSON(src);
+    }
+    async prepareCodeOrigination(params) {
+        const parsedParams = params;
+        parsedParams.code = await this.formatCodeParam(params.code);
+        if (params.init) {
+            parsedParams.init = await this.formatInitParam(params.init);
+        }
+        else if (params.storage) {
+            const storageType = parsedParams.code.find((p) => 'prim' in p && p.prim === 'storage');
+            if (!storageType?.args) {
+                throw new errors_1.InvalidCodeParameter('The storage section is missing from the script', params.code);
+            }
+            const schema = new michelson_encoder_1.Schema(storageType.args[0]);
+            const globalconstantsHashAndValue = await this.findGlobalConstantsHashAndValue(schema);
+            if (Object.keys(globalconstantsHashAndValue).length !== 0) {
+                // If there are global constants in the storage part of the contract code,
+                // they need to be locally expanded in order to encode the storage arguments
+                const p = new michel_codec_1.Parser({ expandGlobalConstant: globalconstantsHashAndValue });
+                const storageTypeNoGlobalConst = p.parseJSON(storageType.args[0]);
+                const schemaNoGlobalConst = new michelson_encoder_1.Schema(storageTypeNoGlobalConst);
+                parsedParams.init = schemaNoGlobalConst.Encode(params.storage);
+            }
+            else {
+                parsedParams.init = schema.Encode(params.storage);
+            }
+            delete parsedParams.storage;
+        }
+        return parsedParams;
+    }
+    async formatCodeParam(code) {
+        let parsedCode;
+        if (typeof code === 'string') {
+            const c = await this.parseScript(code);
+            if (c === null) {
+                throw new errors_1.InvalidCodeParameter('Unable to parse', code);
+            }
+            parsedCode = c;
+        }
+        else {
+            const c = await this.parseJSON(code);
+            const order = ['parameter', 'storage', 'code'];
+            // Ensure correct ordering for RPC
+            parsedCode = c.sort((a, b) => order.indexOf(a.prim) - order.indexOf(b.prim));
+        }
+        return parsedCode;
+    }
+    async formatInitParam(init) {
+        let parsedInit;
+        if (typeof init === 'string') {
+            const c = await this.parseMichelineExpression(init);
+            if (c === null) {
+                throw new errors_1.InvalidInitParameter('Invalid init parameter', init);
+            }
+            parsedInit = c;
+        }
+        else {
+            parsedInit = await this.parseJSON(init);
+        }
+        return parsedInit;
+    }
+    async findGlobalConstantsHashAndValue(schema) {
+        const globalConstantTokens = schema.findToken('constant');
+        const globalConstantsHashAndValue = {};
+        if (globalConstantTokens.length !== 0) {
+            for (const token of globalConstantTokens) {
+                const tokenArgs = token.tokenVal.args;
+                if (tokenArgs) {
+                    const expression = tokenArgs[0];
+                    if (expression.string) {
+                        const hash = expression.string;
+                        const michelineValue = await this.context.globalConstantsProvider.getGlobalConstantByHash(hash);
+                        Object.assign(globalConstantsHashAndValue, {
+                            [hash]: michelineValue,
+                        });
+                    }
+                }
+            }
+        }
+        return globalConstantsHashAndValue;
+    }
+}
+exports.MichelCodecParser = MichelCodecParser;

package/dist/lib/taquito/src/parser/noop-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopParser = void 0;
+class NoopParser {
+    async prepareCodeOrigination(params) {
+        return params;
+    }
+}
+exports.NoopParser = NoopParser;

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

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./prepare-provider"), exports);

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

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