@tezos-x/octez.js 0.9.0

package/dist/lib/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 octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates invalid smart contract parameters being passed or used
+ */
+class InvalidParameterError extends octez_js_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
+ *  @description Error that indicates an invalid delegation source contract address being passed or used
+ */
+class InvalidDelegationSource extends octez_js_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
+ *  @description Error that indicates an invalid smart contract code parameter being passed or used
+ */
+class InvalidCodeParameter extends octez_js_core_1.ParameterValidationError {
+    constructor(message, data) {
+        super();
+        this.message = message;
+        this.data = data;
+        this.name = 'InvalidCodeParameter';
+    }
+}
+exports.InvalidCodeParameter = InvalidCodeParameter;
+/**
+ *  @category Error
+ *  @description Error that indicates invalid smart contract init parameter being passed or used
+ */
+class InvalidInitParameter extends octez_js_core_1.ParameterValidationError {
+    constructor(message, data) {
+        super();
+        this.message = message;
+        this.data = data;
+        this.name = 'InvalidInitParameter';
+    }
+}
+exports.InvalidInitParameter = InvalidInitParameter;
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when conducting a view simulation
+ */
+class ViewSimulationError extends octez_js_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
+ *  @description Error that indicates invalid or unconfigured context when executing a view
+ */
+class InvalidViewSimulationContext extends octez_js_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
+ *  @description Error that indicates a mistake happening during the reveal operation
+ */
+class RevealOperationError extends octez_js_core_1.RpcError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'RevealOperationError';
+    }
+}
+exports.RevealOperationError = RevealOperationError;
+/**
+ *  @category Error
+ *  @description Error that indicates a mistake in the parameters in the preparation of an Origination operation
+ */
+class OriginationParameterError extends octez_js_core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name;
+    }
+}
+exports.OriginationParameterError = OriginationParameterError;
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid balance being passed or used
+ */
+class InvalidBalanceError extends octez_js_core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'InvalidBalanceError';
+    }
+}
+exports.InvalidBalanceError = InvalidBalanceError;

package/dist/lib/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/contract/interface.js

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

package/dist/lib/contract/manager-lambda.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGER_LAMBDA = void 0;
+const setDelegate = (key) => {
+    return [
+        { prim: 'DROP' },
+        { prim: 'NIL', args: [{ prim: 'operation' }] },
+        {
+            prim: 'PUSH',
+            args: [{ prim: 'key_hash' }, { string: key }],
+        },
+        { prim: 'SOME' },
+        { prim: 'SET_DELEGATE' },
+        { prim: 'CONS' },
+    ];
+};
+const transferImplicit = (key, mutez) => {
+    return [
+        { prim: 'DROP' },
+        { prim: 'NIL', args: [{ prim: 'operation' }] },
+        {
+            prim: 'PUSH',
+            args: [{ prim: 'key_hash' }, { string: key }],
+        },
+        { prim: 'IMPLICIT_ACCOUNT' },
+        {
+            prim: 'PUSH',
+            args: [{ prim: 'mutez' }, { int: `${mutez}` }],
+        },
+        { prim: 'UNIT' },
+        { prim: 'TRANSFER_TOKENS' },
+        { prim: 'CONS' },
+    ];
+};
+const removeDelegate = () => {
+    return [
+        { prim: 'DROP' },
+        { prim: 'NIL', args: [{ prim: 'operation' }] },
+        { prim: 'NONE', args: [{ prim: 'key_hash' }] },
+        { prim: 'SET_DELEGATE' },
+        { prim: 'CONS' },
+    ];
+};
+const transferToContract = (key, amount) => {
+    return [
+        { prim: 'DROP' },
+        { prim: 'NIL', args: [{ prim: 'operation' }] },
+        {
+            prim: 'PUSH',
+            args: [{ prim: 'address' }, { string: key }],
+        },
+        { prim: 'CONTRACT', args: [{ prim: 'unit' }] },
+        {
+            prim: 'IF_NONE',
+            args: [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }], []],
+        },
+        {
+            prim: 'PUSH',
+            args: [{ prim: 'mutez' }, { int: `${amount}` }],
+        },
+        { prim: 'UNIT' },
+        { prim: 'TRANSFER_TOKENS' },
+        { prim: 'CONS' },
+    ];
+};
+exports.MANAGER_LAMBDA = {
+    setDelegate,
+    removeDelegate,
+    transferImplicit,
+    transferToContract,
+};

package/dist/lib/contract/prepare.js

@@ -0,0 +1,240 @@
+"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.createSmartRollupExecuteOutboxMessageOperation = exports.createSmartRollupOriginateOperation = exports.createSmartRollupAddMessagesOperation = exports.createUpdateCompanionKeyOperation = exports.createUpdateConsensusKeyOperation = exports.createProposalsOperation = exports.createBallotOperation = exports.createDrainDelegateOperation = exports.createIncreasePaidStorageOperation = exports.createTransferTicketOperation = exports.createRegisterGlobalConstantOperation = exports.createRevealOperation = exports.createRegisterDelegateOperation = exports.createSetDelegateOperation = exports.createTransferOperation = exports.createOriginationOperation = exports.createActivationOperation = void 0;
+const octez_js_michelson_encoder_1 = require("@tezos-x/octez.js-michelson-encoder");
+const octez_js_rpc_1 = require("@tezos-x/octez.js-rpc");
+const constants_1 = require("../constants");
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const errors_1 = require("./errors");
+const createActivationOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ pkh, secret }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.ACTIVATION,
+        pkh,
+        secret,
+    };
+});
+exports.createActivationOperation = createActivationOperation;
+const createOriginationOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ code, init, balance = '0', delegate, storage, fee, gasLimit, storageLimit, mutez = false, }) {
+    if (storage !== undefined && init !== undefined) {
+        throw new errors_1.OriginationParameterError('Storage and Init cannot be set a the same time. Please either use storage or init but not both.');
+    }
+    if (!Array.isArray(code)) {
+        throw new errors_1.InvalidCodeParameter('Wrong code parameter type, expected an array', code);
+    }
+    let contractStorage;
+    if (storage !== undefined) {
+        const storageType = code.find((p) => 'prim' in p && p.prim === 'storage');
+        if ((storageType === null || storageType === void 0 ? void 0 : storageType.args) === undefined) {
+            throw new errors_1.InvalidCodeParameter('The storage section is missing from the script', code);
+        }
+        const schema = new octez_js_michelson_encoder_1.Schema(storageType.args[0]); // TODO
+        contractStorage = schema.Encode(storage);
+    }
+    else if (init !== undefined && typeof init === 'object') {
+        contractStorage = init;
+    }
+    else {
+        throw new errors_1.InvalidInitParameter('Wrong init parameter type, expected JSON Michelson', init);
+    }
+    const script = {
+        code,
+        storage: contractStorage,
+    };
+    if (isNaN(Number(balance))) {
+        throw new errors_1.InvalidBalanceError(`Invalid Balance "${balance}", cannot be converted to a number`);
+    }
+    const operation = {
+        kind: octez_js_rpc_1.OpKind.ORIGINATION,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        balance: mutez ? balance.toString() : (0, octez_js_utils_1.format)('tz', 'mutez', balance).toString(),
+        script,
+    };
+    if (delegate) {
+        operation.delegate = delegate;
+    }
+    return operation;
+});
+exports.createOriginationOperation = createOriginationOperation;
+const createTransferOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ to, amount, parameter, fee, gasLimit, storageLimit, mutez = false, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.TRANSACTION,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        amount: mutez ? amount.toString() : (0, octez_js_utils_1.format)('tz', 'mutez', amount).toString(),
+        destination: to,
+        parameters: parameter,
+    };
+});
+exports.createTransferOperation = createTransferOperation;
+const createSetDelegateOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ delegate, source, fee, gasLimit, storageLimit, }) {
+    const operation = {
+        kind: octez_js_rpc_1.OpKind.DELEGATION,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        delegate,
+    };
+    return operation;
+});
+exports.createSetDelegateOperation = createSetDelegateOperation;
+const createRegisterDelegateOperation = (_a, source_1) => __awaiter(void 0, [_a, source_1], void 0, function* ({ fee, gasLimit, storageLimit }, source) {
+    return {
+        kind: octez_js_rpc_1.OpKind.DELEGATION,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        delegate: source,
+    };
+});
+exports.createRegisterDelegateOperation = createRegisterDelegateOperation;
+const createRevealOperation = (_a, source_1, publicKey_1) => __awaiter(void 0, [_a, source_1, publicKey_1], void 0, function* ({ fee, gasLimit, storageLimit, proof }, source, publicKey) {
+    return {
+        kind: octez_js_rpc_1.OpKind.REVEAL,
+        fee,
+        public_key: publicKey,
+        source,
+        gas_limit: gasLimit !== null && gasLimit !== void 0 ? gasLimit : (0, constants_1.getRevealGasLimit)(source),
+        storage_limit: storageLimit,
+        proof,
+    };
+});
+exports.createRevealOperation = createRevealOperation;
+const createRegisterGlobalConstantOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, source, fee, gasLimit, storageLimit, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT,
+        value,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        source,
+    };
+});
+exports.createRegisterGlobalConstantOperation = createRegisterGlobalConstantOperation;
+const createTransferTicketOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ ticketContents, ticketTy, ticketTicketer, ticketAmount, destination, entrypoint, source, fee, gasLimit, storageLimit, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.TRANSFER_TICKET,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        source,
+        ticket_contents: ticketContents,
+        ticket_ty: ticketTy,
+        ticket_ticketer: ticketTicketer,
+        ticket_amount: ticketAmount,
+        destination,
+        entrypoint,
+    };
+});
+exports.createTransferTicketOperation = createTransferTicketOperation;
+const createIncreasePaidStorageOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, amount, destination, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.INCREASE_PAID_STORAGE,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        amount,
+        destination,
+    };
+});
+exports.createIncreasePaidStorageOperation = createIncreasePaidStorageOperation;
+const createDrainDelegateOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ consensus_key, delegate, destination, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.DRAIN_DELEGATE,
+        consensus_key,
+        delegate,
+        destination,
+    };
+});
+exports.createDrainDelegateOperation = createDrainDelegateOperation;
+const createBallotOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, proposal, ballot }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.BALLOT,
+        source,
+        proposal,
+        ballot,
+    };
+});
+exports.createBallotOperation = createBallotOperation;
+const createProposalsOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, proposals }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.PROPOSALS,
+        source,
+        proposals,
+    };
+});
+exports.createProposalsOperation = createProposalsOperation;
+const createUpdateConsensusKeyOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, pk, proof, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.UPDATE_CONSENSUS_KEY,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        pk,
+        proof,
+    };
+});
+exports.createUpdateConsensusKeyOperation = createUpdateConsensusKeyOperation;
+const createUpdateCompanionKeyOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, pk, proof, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.UPDATE_COMPANION_KEY,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        pk,
+        proof,
+    };
+});
+exports.createUpdateCompanionKeyOperation = createUpdateCompanionKeyOperation;
+const createSmartRollupAddMessagesOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, message, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        message,
+    };
+});
+exports.createSmartRollupAddMessagesOperation = createSmartRollupAddMessagesOperation;
+const createSmartRollupOriginateOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, pvmKind, kernel, parametersType, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.SMART_ROLLUP_ORIGINATE,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        pvm_kind: pvmKind,
+        kernel,
+        parameters_ty: parametersType,
+    };
+});
+exports.createSmartRollupOriginateOperation = createSmartRollupOriginateOperation;
+const createSmartRollupExecuteOutboxMessageOperation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ source, fee, gasLimit, storageLimit, rollup, cementedCommitment, outputProof, }) {
+    return {
+        kind: octez_js_rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE,
+        source,
+        fee,
+        gas_limit: gasLimit,
+        storage_limit: storageLimit,
+        rollup,
+        cemented_commitment: cementedCommitment,
+        output_proof: outputProof,
+    };
+});
+exports.createSmartRollupExecuteOutboxMessageOperation = createSmartRollupExecuteOutboxMessageOperation;