@adapt-toolkit/sdk 0.1.0

package/dist/utilities/wrappers/wrappers/adapt_wrapper.js

@@ -0,0 +1,716 @@
+import { AsyncQueueAdapter, logging, AdaptInitializationError, LazyMessage } from '../../common/index.js';
+import { AdaptObjectBuilder, object_to_adapt_value, Protocol, ReadFile } from '../../../wrapper/index.js';
+import { AdaptEnvironment, AdaptObjectLifetime, AdaptPacketContext } from '@adapt-toolkit/sdk/backend';
+import { AdaptPacketWrapper } from './adapt_packet_wrapper.js';
+import { PacketWrapperConfigurator } from '../configurators/packet_wrapper_configurator.js';
+import path from 'path';
+import { BrokerClient } from '../../broker/index.js';
+import { StorageClient } from '../../storage/index.js';
+import { AdaptNetworkComponentConfigurator } from '../../common/index.js';
+var AdaptWrapperServices;
+(function (AdaptWrapperServices) {
+    class PacketManager {
+        /**
+         * @units is a map of locally available(i.e. previously loaded from the storage) units by its hash.
+         *        Before requesting unit from the data storage, we have to first check, whether we have it locally
+         *
+         * @requested_units is a map of already requested, but not yet received units.
+         *                  It has to contain more than one callback, that should be called when the unit is received, because of the following situation:
+         *                  One adapt wrapper could manage several AdaptPacketWrappers with the same unit code underneath, but created with different seed phrases.
+         *                  Those packets could be requested simultanesously, in this case we don't want to request a unit from a storage multiple times.
+         *                  Instead, we can add a callback to an existing field in the map and call it as soon as we receive a unit from the storage.
+         *
+         * @packets is a map of AdaptPacketWrappers by packet's id. We add a packet there each time, when we create a new packet wrapper.
+         *          It allows us to track packets managed by us and redirect messages addressed to packets.
+         *
+         */
+        #units = new Map(); // locally available units
+        #requested_units = new Map(); // these units have already been requested from data storage, but not yet received
+        #packets = new Map(); // created packets
+        #request_from_storage; // callback to request a unit from the data storage
+        #wrapper;
+        constructor(wrapper, request_from_storage) {
+            this.#wrapper = wrapper;
+            this.#request_from_storage = request_from_storage;
+        }
+        request_unit = (hash, cb) => {
+            logging.debug("Requesting unit: ", hash);
+            if (this.#units.has(hash)) {
+                logging.debug("Unit found: ", hash);
+                cb(this.#units.get(hash));
+            }
+            else if (this.#requested_units.has(hash)) {
+                logging.debug("Unit has already been requested. Waiting: ", hash);
+                this.#requested_units.set(hash, this.#requested_units.get(hash).concat(cb));
+            }
+            else {
+                logging.debug("Requesting unit from the data storage: ", hash);
+                this.#requested_units.set(hash, [cb]);
+                this.#request_from_storage(hash);
+                // request a unit data from the storage
+            }
+        };
+        request_unit_local = (hash, path, cb) => {
+            if (this.#units.has(hash)) {
+                cb(this.#units.get(hash));
+            }
+            else if (this.#requested_units.has(hash)) {
+                this.#requested_units.set(hash, this.#requested_units.get(hash).concat(cb));
+            }
+            this.#requested_units.set(hash, [cb]);
+            try {
+                ReadFile(path).then(data => {
+                    this.add_unit(hash, data);
+                });
+            }
+            catch (e) {
+                throw new AdaptInitializationError("Failed to load a unit from file: " + e);
+            }
+        };
+        add_unit = (hash, data) => {
+            if (!this.#requested_units.has(hash))
+                throw new Error("Internal error: returned unit that wasn't requested: " + hash);
+            this.#requested_units.get(hash).forEach(cb => {
+                cb(data);
+            });
+            this.#requested_units.delete(hash);
+            this.#units.set(hash, data);
+        };
+        add_unit_external = (hash, data) => {
+            this.#units.set(hash, data);
+            this.#requested_units.delete(hash);
+        };
+        add_packet = (id, wrapper) => {
+            if (this.#packets.has(id))
+                throw new Error("Packet with given id already exists: " + id);
+            this.#packets.set(id, wrapper);
+        };
+        remove_packet = (id) => {
+            if (!this.#packets.has(id)) {
+                throw new Error("Attempting to delete a packet with unknown id: " + id);
+            }
+            this.#packets.delete(id);
+        };
+        get packets() {
+            return this.#packets;
+        }
+        init = (packets) => {
+            packets.forEach(config => {
+                // each packet should either have a state hash(backup the packet from storage) or a unit hash(create a new packet from unit loaded from the storage)
+                const packet_id = config.packet_id;
+                const state_hash = config.state_hash;
+                const unit_hash = config.unit_hash;
+                if (config.load_from_storage) {
+                    if (!this.#wrapper.storage_available)
+                        throw new AdaptInitializationError("Failed to load packet from the storage. Storage is not available in the current wrapper configuration.");
+                    if (state_hash || packet_id) {
+                        logging.debug("Backing up a packet.", "State hash: ", state_hash, ", packet id: ", packet_id);
+                        this.#wrapper.back_up_packet(config);
+                    }
+                    else if (unit_hash) {
+                        logging.debug("Creating a packet.");
+                        this.#wrapper.create_packet(config);
+                    }
+                    else
+                        throw new Error("Neither --state_hash nor --unit_hash is specified.");
+                }
+                else {
+                    this.#wrapper.create_packet_local(config);
+                }
+            });
+        };
+        add_packet_local = (packet_config, on_packet_created, unit, _packet) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(async (builder) => {
+                const seed_phrase = packet_config.seed_phrase ? packet_config.seed_phrase : AdaptEnvironment.GetRandomBytes(builder.lifetime, 16).Visualize();
+                const entropy = builder.AdaptEnvironment.GetRandomBytes(256);
+                const init_arg = packet_config.init_arg ? builder.Attach(object_to_adapt_value(JSON.parse(packet_config.init_arg))) : undefined;
+                let packet = _packet
+                    ? builder.Attach(_packet)
+                    : builder.AdaptEnvironment.CreatePacket(unit, "Seed phrase: " + seed_phrase, AdaptNetworkComponentConfigurator.test_mode ? "" : entropy.Visualize().substring(2), false, init_arg).Detach();
+                logging.info("Packet created with id:", packet.GetContainerID().Visualize());
+                let messages_adapt_values = [];
+                if (packet_config instanceof PacketWrapperConfigurator) {
+                    packet_config.transactions.forEach(({ name, targ }) => {
+                        const targ_mufl = packet.ParseValueFromJSON(targ);
+                        const message = object_to_adapt_value({ name: name, targ: targ_mufl });
+                        messages_adapt_values.push(message);
+                    });
+                }
+                let wrapper = new AdaptPacketWrapper(packet, packet_config, this.#wrapper, messages_adapt_values);
+                this.add_packet(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                if (packet_config instanceof PacketWrapperConfigurator)
+                    this.#wrapper.on_packet_created(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                else {
+                    if (!this.#wrapper.control_packet) {
+                        logging.error("Control packet is undefined.");
+                        return;
+                    }
+                    this.#wrapper.control_packet.packet = wrapper;
+                    this.#wrapper.on_control_packet_created(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                }
+                on_packet_created(wrapper);
+            });
+        };
+        create_packet = (packet_config, on_packet_created, unit_contents, _packet) => {
+            const create_packet_cb = () => {
+                AdaptObjectBuilder.execute_and_collect_garbage(async (builder) => {
+                    logging.debug("Loading unit from content");
+                    const unit = builder.AdaptEvaluationUnit.LoadFromContents(unit_contents);
+                    logging.debug("Building packet with seed phrase:", packet_config.seed_phrase);
+                    const seed_phrase = packet_config.seed_phrase ? packet_config.seed_phrase : AdaptEnvironment.GetRandomBytes(builder.lifetime, 16).Visualize();
+                    const entropy = builder.AdaptEnvironment.GetRandomBytes(256);
+                    const init_arg = packet_config.init_arg ? builder.Attach(object_to_adapt_value(JSON.parse(packet_config.init_arg))) : undefined;
+                    let packet = _packet ? builder.Attach(_packet) : builder.AdaptEnvironment.CreatePacket(unit, "Seed phrase: " + seed_phrase, AdaptNetworkComponentConfigurator.test_mode ? "" : entropy.Visualize().substring(2), false, init_arg).Detach();
+                    logging.info("Packet created with id:", packet.GetContainerID().Visualize());
+                    let messages_adapt_values = [];
+                    if (packet_config instanceof PacketWrapperConfigurator) {
+                        packet_config.transactions.forEach(({ name, targ }) => {
+                            const targ_mufl = packet.ParseValueFromJSON(targ);
+                            const message = object_to_adapt_value({ name: name, targ: targ_mufl });
+                            messages_adapt_values.push(message);
+                        });
+                    }
+                    let wrapper = new AdaptPacketWrapper(packet, packet_config, this.#wrapper, messages_adapt_values);
+                    this.add_packet(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                    if (packet_config instanceof PacketWrapperConfigurator)
+                        this.#wrapper.on_packet_created(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                    else {
+                        if (!this.#wrapper.control_packet) {
+                            logging.error("Control packet is undefined.");
+                            return;
+                        }
+                        this.#wrapper.control_packet.packet = wrapper;
+                        this.#wrapper.on_control_packet_created(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                    }
+                    on_packet_created(wrapper);
+                });
+            };
+            create_packet_cb();
+            if (!_packet && packet_config instanceof PacketWrapperConfigurator && packet_config.replicas > 1) {
+                logging.debug("Creating more replicas of the packet: ", packet_config.replicas);
+                packet_config.seed_phrase = undefined;
+                for (let i = 1; i < packet_config.replicas; i++) {
+                    create_packet_cb();
+                }
+            }
+        };
+    }
+    AdaptWrapperServices.PacketManager = PacketManager;
+    class BackupManager {
+        #wrapper;
+        #requested_backups = new Map();
+        #request_backup_data_from_storage;
+        constructor(wrapper, request_backup_data_from_storage) {
+            this.#wrapper = wrapper;
+            this.#request_backup_data_from_storage = request_backup_data_from_storage;
+        }
+        request_backup = (packet_info, on_backup) => {
+            const message_hash = this.#request_backup_data_from_storage(packet_info);
+            this.#requested_backups.set(message_hash, on_backup);
+        };
+        on_backup_data = (message_hash, data) => {
+            if (!this.#requested_backups.has(message_hash))
+                throw new Error("Internal error: unrecognized message hash");
+            this.#requested_backups.get(message_hash)(data);
+            this.#requested_backups.delete(message_hash);
+        };
+        back_up_packet = (packet_config, on_packet_backed_up, backup_data_message) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                const message_body = builder.Attach(Protocol.GetBody(backup_data_message));
+                const packet_data = message_body.Reduce(Protocol.FieldName.packet_data);
+                const transaction_chain = message_body.Reduce(Protocol.FieldName.transaction_chain).Detach();
+                if (packet_data.GetBinary().length === 0) {
+                    logging.info("Backup data for this packet not found.");
+                    if (packet_config.attempt_backup) {
+                        logging.info("Attempt backup option is set. Creating a new packet.");
+                        this.#wrapper.create_packet(packet_config);
+                        return;
+                    }
+                    else {
+                        logging.error("Failed to back up the packet.");
+                        return;
+                    }
+                }
+                let packet = builder.AdaptPacketContext.LoadFromContents(packet_data.GetBinary()).Detach();
+                logging.info("Packet backup up: ", packet.GetContainerID().Visualize());
+                logging.info("Packet code id: ", packet.GetCodeID().Visualize());
+                const unit_hash = packet.GetCodeID();
+                this.#wrapper.packet_manager.request_unit(unit_hash.Visualize().substring(2), unit_contents => {
+                    AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                        builder.Attach(transaction_chain);
+                        builder.AdaptEvaluationUnit.LoadFromContents(unit_contents);
+                        let idx = 0;
+                        let transaction;
+                        while (!(transaction = transaction_chain.Reduce(idx++)).IsNil()) {
+                            const request_data = packet.ExecuteTransaction(builder.Attach(object_to_adapt_value({
+                                name: "::key_storage_api::decrypt_message",
+                                targ: transaction.Reduce(Protocol.FieldName.request_data_encrypted)
+                            })));
+                            const transient_data = packet.ExecuteTransaction(builder.Attach(object_to_adapt_value({
+                                name: "::key_storage_api::decrypt_message",
+                                targ: transaction.Reduce(Protocol.FieldName.transient_data_encrypted)
+                            })));
+                            const trn_result = packet.ExecuteTransaction(request_data, transient_data.Reduce(Protocol.FieldName.entropy).Visualize(), transient_data.Reduce(Protocol.FieldName.timestamp));
+                            packet.Destroy();
+                            packet = trn_result.GetPacket();
+                        }
+                    });
+                    let messages_adapt_values = [];
+                    packet_config.transactions.forEach(({ name, targ }) => {
+                        const targ_mufl = packet.ParseValueFromJSON(targ);
+                        const message = object_to_adapt_value({ name: name, args: targ_mufl });
+                        messages_adapt_values.push(message);
+                    });
+                    let wrapper = new AdaptPacketWrapper(packet, packet_config, this.#wrapper, messages_adapt_values, true);
+                    this.#wrapper.packet_manager.add_packet(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                    logging.info("Packet backed up. ID: ", wrapper.packet.GetContainerID().Visualize());
+                    logging.info("State id: ", wrapper.packet.GetHash().Visualize().substring(2));
+                    this.#wrapper.on_packet_created(wrapper.packet.GetContainerID().Visualize(), wrapper);
+                    on_packet_backed_up(wrapper);
+                });
+            });
+        };
+    }
+    AdaptWrapperServices.BackupManager = BackupManager;
+    class BrokerAPI_impl {
+        #wrapper;
+        #cb;
+        #is_ready = false;
+        #pending_messages = [];
+        #broker_client;
+        // config: AdaptWrapperConfigurator
+        constructor(wrapper) {
+            logging.debug("Creating broker api service");
+            this.#wrapper = wrapper;
+            this.#broker_client = new BrokerClient(wrapper.config.broker_address, this);
+        }
+        start = () => {
+            this.#broker_client.start();
+        };
+        get is_ready() {
+            return this.#is_ready;
+        }
+        receive_from_broker = (message) => {
+            logging.message_received("broker_client", "adapt_wrapper", message);
+            this.#wrapper.receive_message(message);
+        };
+        register_callback_broker = (cb) => {
+            if (this.#cb) {
+                logging.error("Attempting to set the broker callback twice.");
+                return;
+            }
+            this.#cb = cb;
+        };
+        broker_client_ready = () => {
+            this.#is_ready = true;
+            this.#pending_messages.forEach(msg => this.#wrapper.send_to_broker(msg));
+        };
+        send_to_broker = (message) => {
+            if (!this.#cb) {
+                logging.error("Callback to send data to broker is not registered.");
+                return;
+            }
+            if (!this.#is_ready) {
+                this.#pending_messages.push(message);
+                logging.debug("Message added to the list of pending messages: ", new LazyMessage(() => message.Visualize()));
+                return;
+            }
+            logging.message_sent("adapt_wrapper", 'broker_client', message);
+            this.#cb(message);
+        };
+    }
+    AdaptWrapperServices.BrokerAPI_impl = BrokerAPI_impl;
+    class StorageAPI_impl {
+        #wrapper;
+        #cb;
+        #is_ready = false;
+        #pending_messages = [];
+        #storage_client;
+        constructor(wrapper) {
+            this.#wrapper = wrapper;
+            if (wrapper.config.env === 'enclave') {
+                this.#storage_client = new StorageClient(wrapper.config.storage_address, this);
+            }
+        }
+        start() {
+            if (this.#wrapper.config.env === 'enclave')
+                this.#storage_client?.start();
+        }
+        get is_ready() {
+            return this.#is_ready;
+        }
+        receive_from_data_storage = (message) => {
+            logging.message_received("storage_client", "adapt_wrapper", message);
+            this.#wrapper.receive_message(message);
+        };
+        register_callback_data_storage = (cb) => {
+            if (this.#cb) {
+                logging.error("Attempting to set the storage callback twice.");
+                return;
+            }
+            this.#cb = cb;
+        };
+        storage_client_ready = () => {
+            this.#is_ready = true;
+            this.#pending_messages.forEach(msg => this.#wrapper.send_to_storage(msg));
+        };
+        send_to_storage = (message) => {
+            if (!this.#cb) {
+                logging.error("Callback to send data to storage is not regisered.");
+                return;
+            }
+            if (!this.#is_ready) {
+                this.#pending_messages.push(message);
+                logging.debug("Message added to the list of pending messages: ", new LazyMessage(() => message.Visualize()));
+                return;
+            }
+            logging.message_sent("adapt_wrapper", "storage_client", message);
+            this.#cb(message);
+        };
+    }
+    AdaptWrapperServices.StorageAPI_impl = StorageAPI_impl;
+    class MessageProcessor {
+        #wrapper;
+        #queue;
+        #send_to_broker;
+        #send_to_storage;
+        constructor(wrapper, send_to_broker, send_to_storage) {
+            this.#wrapper = wrapper;
+            this.#send_to_broker = send_to_broker;
+            this.#send_to_storage = send_to_storage;
+            this.#queue = new AsyncQueueAdapter(this.#worker.bind(this));
+            this.#queue.add_worker_functions([
+                { type_id: Protocol.MessageName.b2w_init, func: this.b2w_init_handler.bind(this) },
+                { type_id: Protocol.MessageName.b2w_exec_transaction, func: this.b2w_exec_transaction_handler.bind(this) },
+                { type_id: Protocol.MessageName.b2w_reg_ok, func: this.b2w_reg_ok_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_backup_data, func: this.d2w_backup_data_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_create_packet_confirm, func: this.d2w_create_packet_confirm_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_init, func: this.d2w_init_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_code_object, func: this.d2w_code_object_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_last_snapshot_state, func: this.d2w_last_snapshot_state_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_last_state, func: this.d2w_last_state_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_snapshot, func: this.d2w_snapshot_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_transaction_chain, func: this.d2w_transaction_chain_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_write_snapshot_confirm, func: this.d2w_write_snapshot_confirm_handler.bind(this) },
+                { type_id: Protocol.MessageName.d2w_write_transaction_confirm, func: this.d2w_write_transaction_confirm_handler.bind(this) },
+            ]);
+        }
+        push(event) {
+            this.#queue.push(event);
+        }
+        #worker = (event, cb) => {
+            try {
+                if (event.kind === 'incoming') {
+                    logging.debug("Message processed in queue (incoming): ", new LazyMessage(() => event.data.Visualize()));
+                    this.#incoming_message_handler(event.data);
+                }
+                else if (event.kind === 'broker_out') {
+                    logging.debug("Message processed in queue (broker_out): ", new LazyMessage(() => event.data.Visualize()));
+                    this.#send_to_broker(event.data);
+                }
+                else if (event.kind === 'data_storage_out') {
+                    logging.debug("Message processed in queue (storage_out): ", new LazyMessage(() => event.data.Visualize()));
+                    this.#send_to_storage(event.data);
+                }
+            }
+            catch (e) {
+                logging.error(e);
+            }
+            finally {
+                cb();
+            }
+        };
+        #incoming_message_handler = (message) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                builder.Attach(message); // the message is attached here, so it does not need to be attached in the 
+                try {
+                    const type_id = Protocol.GetTypeId(message);
+                    if (type_id[2] === 'd') { // message to data storage
+                        this.#wrapper.send_to_storage(message.Detach());
+                        return;
+                    }
+                    if (type_id[2] === 'b') { // message to broker
+                        this.#wrapper.send_to_broker(message.Detach());
+                        return;
+                    }
+                    const func = this.#queue.get_function(type_id);
+                    if (func)
+                        func(message);
+                    else
+                        logging.error("Adapt wrapper received unrecognized message: ", type_id);
+                }
+                catch (e) {
+                    logging.error(e);
+                }
+            });
+        };
+        #pass_to_adapt_packet_wrapper = (message) => {
+            logging.debug("Passing the message to the packet wrapper: ", new LazyMessage(() => message.Visualize()));
+            this.#wrapper.send_to_packet_wrapper(message.Detach());
+        };
+        b2w_exec_transaction_handler = this.#pass_to_adapt_packet_wrapper;
+        b2w_init_handler = (message) => {
+            logging.error("Internal error: This message is not expected here: ", message.Visualize());
+        };
+        b2w_reg_ok_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_backup_data_handler = (message) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                const message_hash = builder.Attach(Protocol.GetMessageHash(message));
+                this.#wrapper.backup_manager.on_backup_data(message_hash.Visualize(), message);
+            });
+        };
+        d2w_code_object_handler = (message) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                const body = builder.Attach(Protocol.GetBody(message));
+                const unit_contents = body.Reduce(Protocol.FieldName.code_object).Reduce(Protocol.FieldName.code_object_data).GetBinary();
+                const unit_hash = body.Reduce(Protocol.FieldName.code_object).Reduce(Protocol.FieldName.code_object_hash).Visualize().substring(2);
+                this.#wrapper.packet_manager.add_unit(unit_hash, unit_contents);
+            });
+        };
+        d2w_create_packet_confirm_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_init_handler = (message) => {
+            logging.error("Internal error: This message is not expected here: ", message.Visualize());
+        };
+        d2w_last_snapshot_state_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_last_state_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_snapshot_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_transaction_chain_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_write_snapshot_confirm_handler = this.#pass_to_adapt_packet_wrapper;
+        d2w_write_transaction_confirm_handler = this.#pass_to_adapt_packet_wrapper;
+    }
+    AdaptWrapperServices.MessageProcessor = MessageProcessor;
+    class Helpers {
+        #wrapper;
+        constructor(wrapper) {
+            this.#wrapper = wrapper;
+        }
+        request_unit_from_storage = (unit_hash) => {
+            AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                logging.debug('Unit hash is ', unit_hash);
+                const emptyPacket = AdaptEnvironment.EmptyPacket(undefined, false);
+                const unit_hash_adapt_value = builder.Attach(emptyPacket.ExecuteFunction("_binary_to_hash_code", [emptyPacket.ExecuteFunction('_hex_string_to_binary', [unit_hash])]));
+                // const unit_hash_adapt_value = builder.Attach(
+                //     Protocol.GetProtocolContainer().ExecuteTransaction(
+                //         builder.Attach(object_to_adapt_value({
+                //             name: "::protocol_container::primitives_wrapper::binary_to_hash_code",
+                //             targ: builder.Attach(Protocol.GetProtocolContainer().ExecuteTransaction(
+                //                 builder.Attach(object_to_adapt_value({
+                //                     name: "::protocol_container::primitives_wrapper::hex_string_to_binary",
+                //                     targ: unit_hash
+                //                 }))
+                //             ))
+                //
+                //         }))
+                //     )
+                // );
+                const args = builder.Attach(Protocol.GetProtocolContainer().CreateDictionary().Mutate(Protocol.FieldName.code_object_hash, unit_hash_adapt_value));
+                const message = Protocol.CreateProtocolMessage(Protocol.MessageName.w2d_get_code_object, { body: args }).Detach();
+                logging.debug("Setting new packet with message hash:", new LazyMessage(() => message.GetHash().Visualize()));
+                this.#wrapper.send_to_storage(message);
+            });
+        };
+        request_backup_data_from_storage = ({ packet_id, state }) => {
+            if (!packet_id && !state)
+                throw new Error("Internal error: both packet id and state hash are undefined while trying to request packet backup data.");
+            if (state)
+                logging.debug("Attempting to back up a packet to a state: ", state);
+            else if (packet_id)
+                logging.debug("Attempting to back up a packet to the most recent state. Packet id: ", packet_id);
+            return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+                const packet = builder.AdaptPacketContext.EmptyPacket(false);
+                if (state) {
+                    logging.debug("State is ", state);
+                }
+                const emptyPacket = AdaptEnvironment.EmptyPacket(undefined, false);
+                const stateAdaptValue = state ? builder.Attach(emptyPacket.ExecuteFunction('_binary_to_hash_code', [builder.Attach(emptyPacket.ExecuteFunction('_hex_string_to_binary', [state]))])) : undefined;
+                // const stateAdaptValue = state ? builder.Attach(
+                //     Protocol.GetProtocolContainer().ExecuteTransaction(
+                //         builder.Attach(object_to_adapt_value({
+                //             name: "::protocol_container::primitives_wrapper::binary_to_hash_code",
+                //             targ: builder.Attach(Protocol.GetProtocolContainer().ExecuteTransaction(
+                //                 builder.Attach(object_to_adapt_value({
+                //                     name: "::protocol_container::primitives_wrapper::hex_string_to_binary",
+                //                     targ: state
+                //                 }))
+                //             ))
+                //         }))
+                //     )
+                // ) : undefined;
+                // create backup data request to the data storage
+                const message = Protocol.CreateProtocolMessage(Protocol.MessageName.w2d_request_backup_data, {
+                    body: packet.CreateDictionary()
+                        .Mutate(Protocol.FieldName.packet_id, packet_id ? packet_id : packet.Nil())
+                        .Mutate(Protocol.FieldName.state, stateAdaptValue ? stateAdaptValue : packet.Nil())
+                });
+                const message_hash = message.GetHash().Visualize();
+                this.#wrapper.send_to_storage(message);
+                return message_hash;
+            });
+        };
+    }
+    AdaptWrapperServices.Helpers = Helpers;
+    class ControlPacket {
+        #wrapper;
+        packet;
+        constructor(wrapper, config) {
+            this.#wrapper = wrapper;
+            const on_unit_data = this.#wrapper.packet_manager.create_packet.bind(this, config, () => { });
+            if (config.load_from_storage) {
+                this.#wrapper.packet_manager.request_unit(config.unit_hash, on_unit_data);
+            }
+            else {
+                const control_packet_unit_dir = config.control_packet_dir_path;
+                const control_packet_path = path.join(control_packet_unit_dir, config.unit_hash + ".muflo").normalize();
+                this.#wrapper.packet_manager.request_unit_local(config.unit_hash, control_packet_path, on_unit_data);
+            }
+        }
+    }
+    AdaptWrapperServices.ControlPacket = ControlPacket;
+})(AdaptWrapperServices || (AdaptWrapperServices = {}));
+export class AdaptWrapper {
+    config;
+    #broker_service = new AdaptWrapperServices.BrokerAPI_impl(this);
+    // receive_from_broker = this.#broker_service.receive_from_broker.bind(this.#broker_service);
+    // register_callback_broker = this.#broker_service.register_callback_broker.bind(this.#broker_service);
+    // broker_client_ready = this.#broker_service.broker_client_ready.bind(this.#broker_service);
+    get is_broker_ready() {
+        return this.#broker_service.is_ready;
+    }
+    #send_to_broker = this.#broker_service.send_to_broker.bind(this.#broker_service);
+    #storage_service = new AdaptWrapperServices.StorageAPI_impl(this);
+    // receive_from_data_storage = this.#storage_service.receive_from_data_storage.bind(this.#storage_service);
+    // register_callback_data_storage = this.#storage_service.register_callback_data_storage.bind(this.#storage_service);
+    // storage_client_ready = this.#storage_service.storage_client_ready.bind(this.#storage_service);
+    get is_storage_ready() {
+        return this.#storage_service.is_ready;
+    }
+    get storage_available() {
+        return this.config.env === 'enclave';
+    }
+    #send_to_storage = this.#storage_service.send_to_storage.bind(this.#storage_service);
+    #helpers = new AdaptWrapperServices.Helpers(this);
+    #request_unit_from_storage = this.#helpers.request_unit_from_storage.bind(this.#helpers);
+    #request_backup_data_from_storage = this.#helpers.request_backup_data_from_storage.bind(this.#helpers);
+    packet_manager = new AdaptWrapperServices.PacketManager(this, this.#request_unit_from_storage.bind(this));
+    backup_manager = new AdaptWrapperServices.BackupManager(this, this.#request_backup_data_from_storage.bind(this));
+    #message_processor = new AdaptWrapperServices.MessageProcessor(this, this.#send_to_broker.bind(this), this.#send_to_storage.bind(this));
+    control_packet;
+    constructor(config) {
+        this.config = config;
+        logging.info("Calling constructor of adapt wrapper");
+        // this.config = config;
+    }
+    // =================================== public API ==============================================
+    receive_message(message) {
+        this.#message_processor.push({ kind: "incoming", data: message });
+    }
+    send_to_packet_wrapper(message) {
+        AdaptObjectBuilder.execute_and_collect_garbage(builder => {
+            const to = builder.Attach(Protocol.GetTo(message)).Visualize();
+            // if (this.control_packet.)
+            if (this.packet_manager.packets.has(to))
+                this.packet_manager.packets.get(to).on_message(message);
+            else {
+                logging.error("Packet with id ", to, " is not known.");
+            }
+        });
+    }
+    send_to_storage(message) {
+        this.#message_processor.push({ kind: "data_storage_out", data: message });
+    }
+    send_to_broker(message) {
+        this.#message_processor.push({ kind: "broker_out", data: message });
+    }
+    create_packet(config, on_packet_created = (() => { }), packet) {
+        this.packet_manager.request_unit(config.unit_hash, (contents) => this.packet_manager.create_packet(config, on_packet_created, contents, packet));
+    }
+    create_packet_ex(unit_hash, seed_phrase, on_packet_created = (() => { }), packet) {
+        let config = new PacketWrapperConfigurator();
+        config.unit_hash = unit_hash;
+        config.seed_phrase = seed_phrase;
+        this.create_packet(config, on_packet_created, packet);
+    }
+    create_packet_local(config, on_packet_created = (() => { })) {
+        let packet;
+        let unit_hash;
+        if (config.state_hash) {
+            const state_hash = config.state_hash;
+            const packet_path = config.packet_dir_path + "/" + state_hash + ".muflp";
+            try {
+                packet = AdaptPacketContext.LoadFromFile(new AdaptObjectLifetime(), packet_path).Detach();
+            }
+            catch (e) {
+                throw new AdaptInitializationError("Failed to load a packet from file: " + e);
+            }
+            unit_hash = packet.GetCodeID().Visualize();
+            if (config.unit_hash !== unit_hash)
+                throw new AdaptInitializationError("Provided packet and code do not match.");
+        }
+        else {
+            if (!config.unit_hash)
+                throw new AdaptInitializationError("Unit hash is not provided.");
+            unit_hash = config.unit_hash;
+        }
+        this.packet_manager.request_unit_local(unit_hash, config.unit_dir_path + "/" + unit_hash + ".muflo", content => {
+            return this.packet_manager.create_packet(config, on_packet_created, content, packet);
+        });
+    }
+    back_up_packet(config, on_packet_backed_up = (() => { })) {
+        const state_hash = config.state_hash;
+        const packet_id = config.packet_id;
+        this.backup_manager.request_backup({ packet_id: packet_id, state: state_hash }, this.backup_manager.back_up_packet.bind(this, config, on_packet_backed_up));
+    }
+    back_up_packet_ex({ packet_id, state }, on_packet_backed_up = (() => { })) {
+        let config = new PacketWrapperConfigurator();
+        config.packet_id = packet_id;
+        config.state_hash = state;
+        this.back_up_packet(config, on_packet_backed_up);
+    }
+    remove_packet(packet_id) {
+        this.packet_manager.remove_packet(packet_id);
+    }
+    #on_container_created_cb;
+    #on_control_packet_created_cbs = [];
+    set on_packet_created_cb(cb) {
+        console.log("Packet created cb is set");
+        this.#on_container_created_cb = cb;
+    }
+    set on_control_packet_created_cb(cb) {
+        this.#on_control_packet_created_cbs.push(cb);
+    }
+    on_packet_created(cid, wrapper) {
+        if (this.#on_container_created_cb)
+            this.#on_container_created_cb(cid, wrapper);
+    }
+    on_control_packet_created(cid, wrapper) {
+        this.#on_control_packet_created_cbs.forEach(cb => cb(cid, wrapper));
+    }
+    add_packet(unit_hash, seed_phrase, on_packet_created = (() => { }), packet) {
+        logging.debug("Adding packet");
+        return this.create_packet_ex(unit_hash, seed_phrase, on_packet_created, packet);
+    }
+    add_packet_local(on_packet_created, unit, packet) {
+        logging.debug("add_packet_local");
+        this.packet_manager.add_packet_local(new PacketWrapperConfigurator(), on_packet_created, unit, packet);
+    }
+    add_unit(unit_hash, unit_data) {
+        logging.debug("Adding unit: ", unit_hash);
+        this.packet_manager.add_unit_external(unit_hash, unit_data);
+    }
+    start() {
+        this.#broker_service.start();
+        this.#storage_service.start();
+        if (this.config.env === 'enclave') {
+            this.on_control_packet_created_cb = () => {
+                this.packet_manager.init(this.config.packets);
+            };
+            if (!this.config.control_packet)
+                throw new AdaptInitializationError("Control packet configuration is not provided in nitro enclave environment.");
+            this.control_packet = new AdaptWrapperServices.ControlPacket(this, this.config.control_packet);
+        }
+        else {
+            this.packet_manager.init(this.config.packets);
+        }
+    }
+}
+//# sourceMappingURL=adapt_wrapper.js.map