@adapt-toolkit/sdk 0.5.15 → 0.6.0

package/dist/utilities/wrappers/wrappers/impl/adapt_packet_wrapper_impl.js

@@ -1,611 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { AdaptObjectBuilder, ExitHandlerRegistrar, object_to_adapt_value, Protocol } from '../../../../wrapper/index.js';
-import { AdaptProtocolError, AdaptProtocolErrorType, AdaptWaitlist, AsyncQueueAdapter, Callback, LazyMessage, LoggerProxy, logging, log_fn_call, MessageDependency } from '../../../common/index.js';
-import { AdaptEnvironment, AdaptObjectLifetime } from '@adapt-toolkit/sdk/backend';
-import { ControlPacketConfigurator } from "../../configurators/control_packet_configurator.js";
-import { ControlPacket } from "../../enclave/control_packet.js";
-const adapt_packet_wrapper_impl_logger_proxy = new LoggerProxy("adapt packet wrapper impl");
-export class AdaptPacketWrapperImpl {
-    adapt_wrapper;
-    builder = new AdaptObjectBuilder();
-    queue = new AsyncQueueAdapter(this.worker.bind(this));
-    worker_functions;
-    registration_accepted = false;
-    pending_messages = [];
-    waitlist;
-    pending_transactions;
-    first_messages;
-    prepared_to_execute_first_messages = false;
-    // web code sets this callback. Packet Wrapper calls this callback on every verify request from the packet
-    #on_verify_request;
-    // same here, setter is only availabe in browser
-    #on_return_data;
-    #on_transaction_failure;
-    container_id;
-    packet;
-    identity_proof_document;
-    control_packet;
-    create_create_packet_message() {
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const args = builder.Attach(this.packet.CreateDictionary()
-                .Mutate(Protocol.FieldName.packet_info, builder.Attach(this.packet.CreateDictionary().Mutate(Protocol.FieldName.packet_id, this.packet.GetContainerID()).Mutate(Protocol.FieldName.state, this.packet.GetHash()))));
-            const create_packet = Protocol.CreateProtocolMessage(Protocol.MessageName.w2d_create_packet, { from: this.packet.GetContainerID(), body: args }).Detach();
-            return create_packet;
-        }, e => {
-            const message = e instanceof Error ? e.message : e;
-            throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Internal error: while trying to create 'create_packet' message: " + message);
-        });
-    }
-    create_write_snapshot_message() {
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            // send snapshot data to the data storage
-            const packet_arg = builder.Attach(this.packet.CreateDictionary().Mutate(Protocol.FieldName.packet_data, this.packet.NewBinaryFromHex(Buffer.from(this.packet.Serialize()).toString('hex'))).Mutate(Protocol.FieldName.packet_info, builder.Attach(this.packet.CreateDictionary().Mutate(Protocol.FieldName.packet_id, this.packet.GetContainerID()).Mutate(Protocol.FieldName.state, this.packet.GetHash()))));
-            let write_snapshot_args = builder.Attach(this.packet.CreateDictionary().Mutate(Protocol.FieldName.packet, packet_arg));
-            const write_snapshot = Protocol.CreateProtocolMessage(Protocol.MessageName.w2d_write_snapshot, { from: builder.AdaptValue.New(this.packet.GetContainerID()), body: write_snapshot_args }).Detach();
-            return write_snapshot;
-        }, e => {
-            const message = e instanceof Error ? e.message : e;
-            throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Internal error: while trying to create 'write snapshot' message:" + message);
-        });
-    }
-    load_attestation_document(is_control_packet = false) {
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const execute_transaction = (trn_body) => {
-                builder.Attach(trn_body);
-                logging.info("Executing transaction in the packet: ", trn_body.Visualize());
-                const trn_result = builder.Attach(this.packet.ExecuteTransaction(trn_body));
-                const result_type = Protocol.GetTransactionResultKind(trn_result);
-                if (result_type !== 'SUC')
-                    throw new Error("Internal error: transaction " + trn_body.Reduce(Protocol.FieldName.name).Visualize() + " failed.");
-                logging.info("Packet state updated. Previous state: ", builder.Attach(this.packet.GetHash()).Visualize().substring(2));
-                if (this.packet.lifetime == this.builder.lifetime || !this.packet.lifetime)
-                    this.packet.Destroy();
-                this.packet = trn_result.GetPacket().Clone(this.builder.lifetime);
-                logging.info("New state: ", builder.Attach(this.packet.GetHash()).Visualize().substring(2));
-            };
-            if (!is_control_packet && this.adapt_wrapper.config.env === 'enclave') {
-                if (!this.adapt_wrapper.control_packet || !this.adapt_wrapper.control_packet.packet) {
-                    throw new Error("Control packet in enclave was not set.");
-                }
-                const control_packet_ip_document = builder.Attach(this.adapt_wrapper.control_packet.packet.identity_proof_document);
-                execute_transaction(object_to_adapt_value({
-                    name: "::control_packet_identity_proof_document::set_identity_proof_document",
-                    targ: control_packet_ip_document
-                }));
-            }
-            execute_transaction(object_to_adapt_value({
-                name: "::platform_dependent_attestation_document::load_attestation_document",
-                targ: this.packet.ExecuteTransaction(builder.Attach(object_to_adapt_value({
-                    name: "::attestation_document::create",
-                    targ: false
-                })))
-            }));
-        }, e => {
-            const message = e instanceof Error ? e.message : e;
-            throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Internal error while creating attestation document: " + message);
-        });
-    }
-    create_registration_message() {
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const args = builder.Attach(Protocol.GetProtocolContainer().CreateDictionary().Mutate(Protocol.FieldName.ip_document, builder.Attach(Protocol.GetIdentityProofDocument(this.packet))));
-            const message = Protocol.CreateProtocolMessage(Protocol.MessageName.w2b_reg, { from: builder.AdaptValue.New(builder.Attach(this.packet.GetContainerID())), body: args }).Detach();
-            return message;
-        }, e => {
-            const message = e instanceof Error ? e.message : e;
-            throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Internal error while creating registration message: " + message);
-        });
-    }
-    constructor(adapt_packet_wrapper, packet, config, adapt_wrapper, messages, is_backup) {
-        this.adapt_wrapper = adapt_wrapper;
-        this.packet = packet;
-        this.builder.Attach(this.packet);
-        // Finalize this wrapper's builder lifetime at process exit so the packet,
-        // identity-proof document, and anything scoped to it are freed (mirrors the
-        // protocol container's exit handler). Without this they outlive the process
-        // and the leak tracker reports them.
-        // Free this.packet explicitly (it may have drifted off builder.lifetime after a
-        // reassignment) then finalize the builder for everything else scoped to it.
-        ExitHandlerRegistrar.getInstance().registerOnExitHandler(() => { this.packet.Destroy(); this.builder.Destroy(); });
-        this.container_id = AdaptObjectBuilder.execute_and_collect_garbage(b => b.Attach(this.packet.GetContainerID()).Visualize());
-        this.control_packet = config instanceof ControlPacketConfigurator ? new ControlPacket(config, adapt_packet_wrapper, adapt_wrapper) : undefined;
-        this.waitlist = new AdaptWaitlist();
-        logging.debug("Creating adapt packet wrapper.");
-        this.worker_functions = new Map([
-            [Protocol.MessageName.b2w_reg_ok, this.b2w_reg_ok_v1_handler.bind(this)],
-            [Protocol.MessageName.b2w_exec_transaction, this.b2w_exec_transaction_v1_handler.bind(this)],
-            [Protocol.MessageName.d2w_write_transaction_confirm, this.d2w_write_transaction_confirm_v1_handler.bind(this)],
-            [Protocol.MessageName.d2w_write_snapshot_confirm, this.d2w_write_snapshot_confirm_v1_handler.bind(this)],
-            [Protocol.MessageName.d2w_create_packet_confirm, this.d2w_create_packet_confirm_v1_handler.bind(this)]
-        ]);
-        this.queue.resume();
-        this.pending_transactions = new AsyncQueueAdapter(this.pending_transactions_worker.bind(this));
-        if (!is_backup)
-            this.load_attestation_document(config instanceof ControlPacketConfigurator);
-        this.identity_proof_document = this.builder.Attach(this.packet.ExecuteTransaction(this.builder.Attach(object_to_adapt_value({
-            name: "::identity_proof_document::create",
-            targ: undefined
-        }))));
-        this.first_messages = messages;
-        const first_message_cb = (() => {
-            logging.info(`Packet with id ${AdaptObjectBuilder.execute_and_collect_garbage(b => b.Attach(this.packet.GetContainerID()).Visualize())} created and prepared to execute first messages.`);
-            this.prepared_to_execute_first_messages = true;
-            this.first_messages.forEach(message => this.on_first_message(message));
-        }).bind(this);
-        const registration_message_callback = (() => {
-            const registration_message = this.create_registration_message();
-            this.send_to_adapt_wrappper_impl(registration_message, true);
-        }).bind(this);
-        if (is_backup) {
-            registration_message_callback();
-            first_message_cb();
-        }
-        else if (this.adapt_wrapper.storage_available) {
-            logging.debug("Creating packet wrapper with available data storage.");
-            const create_packet_message = this.create_create_packet_message();
-            const write_snapshot_message = this.create_write_snapshot_message();
-            logging.debug("Sending the registration message to the broker and create packet/write snapshot messages to the data storage.");
-            this.waitlist.add([
-                new MessageDependency(create_packet_message.GetHash().Visualize(), new Callback(this.send_to_adapt_wrapper.bind(this, write_snapshot_message))),
-                new MessageDependency(write_snapshot_message.GetHash().Visualize(), new Callback(registration_message_callback))
-            ], first_message_cb);
-            this.send_to_adapt_wrapper(create_packet_message);
-        }
-        else {
-            logging.debug("Created packet without access to the data storage.");
-            logging.debug("Sending the registration message to the broker.");
-            registration_message_callback();
-            logging.debug("Executing first messages.");
-            first_message_cb();
-        }
-    }
-    add_client_message(message) {
-        let messages = [].concat(message);
-        if (this.prepared_to_execute_first_messages) {
-            messages.forEach(m => this.on_client_message(m));
-        }
-        else {
-            this.first_messages.push(...messages);
-        }
-    }
-    /**
-     * Message from the adapt wrapper
-     * @param message
-     */
-    on_message(message) {
-        // message processing logic
-        logging.message_received('adapt_wrapper', 'packet_wrapper', message, this.packet);
-        this.queue.push({
-            kind: 'incoming_message',
-            data: message
-        });
-    }
-    send_to_adapt_wrapper(message) {
-        this.queue.push({
-            kind: 'outgoing_message',
-            data: message
-        });
-    }
-    transaction_destination(message) {
-        if (Protocol.GetTypeId(message) !== Protocol.MessageName.w2b_transaction)
-            return undefined;
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => builder.Attach(Protocol.GetTo(message)).Visualize());
-    }
-    is_local_transaction(message) {
-        const to = this.transaction_destination(message);
-        return to !== undefined && this.adapt_wrapper.packet_manager.packets.has(to);
-    }
-    flush_pending_messages_for(container_id) {
-        if (this.pending_messages.length === 0)
-            return;
-        const flushed = [];
-        this.pending_messages = this.pending_messages.filter(message => {
-            if (this.transaction_destination(message) !== container_id)
-                return true;
-            flushed.push(message);
-            return false;
-        });
-        flushed.forEach(message => this.send_to_adapt_wrapper(message));
-    }
-    send_to_adapt_wrappper_impl(message, registration_message = false) {
-        const type_id = Protocol.GetTypeId(message);
-        let to_storage = type_id.startsWith('w2d');
-        if (!to_storage && !this.registration_accepted && !registration_message && !this.is_local_transaction(message)) {
-            logging.debug("Message not forwarded to adapt wrapper. Registration wasn't accepted yet.");
-            logging.debug("Adding message to the list of pending messages:", new LazyMessage(() => message.Visualize()));
-            this.pending_messages.push(message);
-            return;
-        }
-        logging.message_sent('packet_wrapper', 'adapt_wrapper', message);
-        this.adapt_wrapper.receive_message(message);
-    }
-    on_first_message(message) {
-        logging.debug('Received first message:', new LazyMessage(() => new LazyMessage(() => message.Visualize())));
-        this.queue.push({
-            kind: 'first_or_client_message',
-            data: message
-        });
-    }
-    on_client_message(message) {
-        logging.debug("Received message from a client:", new LazyMessage(() => message.Visualize()));
-        this.queue.push({
-            kind: 'first_or_client_message',
-            data: message
-        });
-    }
-    worker(task, cb) {
-        try {
-            if (task.kind === 'incoming_message') {
-                this.incoming_message_handler(task);
-            }
-            else if (task.kind === 'first_or_client_message') {
-                this.first_or_client_message_handler(task);
-            }
-            else {
-                this.send_to_adapt_wrappper_impl(task.data);
-            }
-        }
-        catch (e) {
-            logging.error(e instanceof Error ? e.stack : e);
-        }
-        finally {
-            cb();
-        }
-    }
-    first_or_client_message_handler(task) {
-        this.b2w_exec_transaction_v1_handler(task.data, true);
-    }
-    incoming_message_handler(task) {
-        const message_type_id = Protocol.GetTypeId(task.data);
-        const func = this.worker_functions.get(message_type_id);
-        if (func)
-            func(task.data);
-        else
-            throw new AdaptProtocolError(AdaptProtocolErrorType.INVALID_MESSAGE, "Unrecognized message type id: " + message_type_id.toString());
-    }
-    b2w_reg_ok_v1_handler(message) {
-        message.Destroy();
-        if (this.registration_accepted) {
-            logging.debug("Ignoring duplicate registration confirmation from broker");
-            return;
-        }
-        logging.debug("Adapt wrapper received confirmation of registration from broker");
-        this.registration_accepted = true;
-        const pending = this.pending_messages;
-        this.pending_messages = [];
-        for (let i = pending.length - 1; i >= 0; i--) {
-            this.queue.unshift({
-                kind: 'outgoing_message',
-                data: pending[i]
-            });
-        }
-    }
-    d2w_write_transaction_confirm_v1_handler(message) {
-        this.process_confirmation_message(message);
-    }
-    d2w_write_snapshot_confirm_v1_handler(message) {
-        this.process_confirmation_message(message);
-    }
-    d2w_create_packet_confirm_v1_handler(message) {
-        this.process_confirmation_message(message);
-    }
-    process_confirmation_message(message) {
-        AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            builder.Attach(message);
-            const message_hash = builder.Attach(Protocol.GetMessageHash(message));
-            this.waitlist.satisfy(message_hash.Visualize(), message.Clone());
-        }, e => {
-            const message = e instanceof Error ? e.message : e;
-            throw new Error("Error while processing confirmation message: " + message);
-        });
-    }
-    /**
-     * Transactions processing workflow:
-     * When b2w_exec_transaction_v1 is received by adapt packet wrapper, the message is added to the queue of pending transactions.
-     * This queue process one transactions at time.
-     */
-    b2w_exec_transaction_v1_handler(message, is_first_message = false) {
-        //  Ensure, that container id in 'to' field is the same as the container id manages by the wrapper and validate attestation document of the issuer container
-        if (is_first_message) {
-            this.pending_transactions.push({ trn: message, is_user_transaction: true });
-            return;
-        }
-        AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const to = builder.Attach(Protocol.GetTo(message));
-            if (!to.Equals(builder.Attach(this.packet.GetContainerID())))
-                throw new AdaptProtocolError(AdaptProtocolErrorType.LOGIC_ERROR, "Invalid container id of incoming transaction message." + "Expected: " + builder.Attach(this.packet.GetContainerID()).Visualize() + ", but received: " + to.Visualize());
-            const body = builder.Attach(Protocol.GetBody(message));
-            const ip_document = body.Reduce(Protocol.FieldName.ip_document);
-            // TODO: check if attestation document of the container is known to us, if not, attestation document in the message should not be NIL
-            // if (!is_first_message) {
-            //     try {
-            //         builder.Attach(Protocol.ValidateIdentityProofDocument(ip_document, builder.AdaptEnvironment.SystemTime()));
-            //     } catch (e) {
-            //         const message = e instanceof Error ? e.message : e;
-            //         throw new AdaptProtocolError(AdaptProtocolErrorType.IP_DOCUMENT_VALIDATION_FAILURE, "Attestation document validation failed: " + message);
-            //     }
-            // }
-            // logging.debug("Idenity proof document validated.");
-        });
-        // add transaction to the queue of pending transactions
-        this.pending_transactions.push({ trn: message, is_user_transaction: false });
-    }
-    // ========================= pending transactions worker and related methods ======================
-    pending_transactions_worker(event, cb) {
-        try {
-            this.execute_transaction(event);
-        }
-        catch (e) {
-            const message = e instanceof Error ? e.message : e;
-            logging.error("while executing transaction:", message);
-            if (this.#on_transaction_failure && e instanceof Error) {
-                this.#on_transaction_failure(e.message);
-            }
-            this.pending_transactions.resume(); // if transaction failed, next transactions can be processed
-        }
-        finally {
-            cb();
-        }
-    }
-    create_write_transaction_message(trn_result, transient_data_encrypted, request_data_encrypted) {
-        return AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const args = builder.Attach(Protocol.GetProtocolContainer().CreateDictionary()
-                .Mutate(Protocol.FieldName.state_change, builder.Attach(Protocol.GetProtocolContainer().CreateDictionary())
-                .Mutate(Protocol.FieldName.final_state_id, 
-            // trn_result is Detach()ed in execute_transaction, so its GetPacket()
-            // wrapper has no lifetime; scope it so it is freed with this builder.
-            builder.Attach(trn_result.GetPacket()).GetHash())
-                .Mutate(Protocol.FieldName.transaction, builder.Attach(Protocol.GetProtocolContainer().CreateDictionary().
-                Mutate(Protocol.FieldName.transient_data_encrypted, transient_data_encrypted).
-                Mutate(Protocol.FieldName.request_data_encrypted, request_data_encrypted))))
-                .Mutate(Protocol.FieldName.packet_info, builder.Attach(Protocol.CreatePacketInfo(this.packet))));
-            const write_transaction_message = Protocol.CreateProtocolMessage(Protocol.MessageName.w2d_write_transaction, { from: builder.AdaptValue.New(this.packet.GetContainerID()), body: args }).Detach();
-            return write_transaction_message;
-        });
-    }
-    execute_transaction({ trn, is_user_transaction }) {
-        this.pending_transactions.pause();
-        const builder = new AdaptObjectBuilder();
-        try {
-            // The incoming transaction message is consumed by this call; scope it so it
-            // is freed with the builder. This also frees locally-delivered envelopes
-            // (#deliver_locally builds them via CreateProtocolMessage and hands them in
-            // as `trn`), which otherwise leak once per local transaction.
-            builder.Attach(trn);
-            let envelope;
-            if (is_user_transaction) {
-                logging.debug("Executing user transaction in the packet: ", new LazyMessage(() => trn.Visualize()));
-                envelope = trn;
-            }
-            else {
-                logging.debug("Executing a transaction in the packet");
-                const body = builder.Attach(Protocol.GetBody(trn));
-                envelope = body.Reduce(Protocol.FieldName.envlp);
-                const trn_body = envelope.Reduce(Protocol.FieldName.body);
-                logging.debug("Executing transaction: ", new LazyMessage(() => builder.Attach(Protocol.DescribeTransaction(this.packet, trn_body)).Visualize()));
-            }
-            // generate and save entropy and timestamp
-            const entropy = builder.AdaptEnvironment.GetRandomBytes(256);
-            const time = builder.AdaptEnvironment.SystemTime();
-            // execute transaction
-            const trn_result = this.packet.ExecuteTransaction(envelope, entropy.Visualize().substring(2), time).Detach();
-            logging.info("Adapt transaction output: ", AdaptEnvironment.getStdoutContents(), AdaptEnvironment.getStderrContents());
-            // check, whether transaction succeeded. Otherwise, do not continue processing the transaction
-            const transaction_result_type = Protocol.GetTransactionResultKind(trn_result);
-            if (transaction_result_type === 'FAIL') {
-                throw new AdaptProtocolError(AdaptProtocolErrorType.TRANSACTION_FAILURE, "Transaction failed with message " + trn_result.Reduce(Protocol.FieldName.result).Visualize());
-            }
-            logging.debug("Container hash before transaction:", new LazyMessage(() => this.packet.GetHash().Visualize()));
-            logging.debug("Transaction result:", new LazyMessage(() => trn_result.Visualize()));
-            logging.debug("Container hash after transaction:", new LazyMessage(() => AdaptObjectBuilder.execute_and_collect_garbage(b => b.Attach(trn_result.GetPacket()).GetHash().Visualize())));
-            if (this.adapt_wrapper.storage_available) {
-                // encrypt transaction request and transient data with encryption key of this container
-                const transient_data = builder.Attach(this.packet.CreateDictionary().Mutate(Protocol.FieldName.timestamp, time).Mutate(Protocol.FieldName.entropy, entropy.Visualize().substring(2)));
-                const transient_data_encrypted = builder.Attach(this.packet.ExecuteTransaction(builder.Attach(object_to_adapt_value({
-                    name: "::key_storage_api::default_encrypt",
-                    targ: builder.Attach(object_to_adapt_value({
-                        message: transient_data,
-                        recipient_container_id: this.packet.GetContainerID()
-                    }))
-                }))));
-                const request_data_encrypted = builder.Attach(this.packet.ExecuteTransaction(builder.Attach(object_to_adapt_value({
-                    name: "::key_storage_api::default_encrypt",
-                    targ: builder.Attach(object_to_adapt_value({
-                        message: envelope,
-                        recipient_container_id: this.packet.GetContainerID()
-                    }))
-                }))));
-                const write_transaction_message = this.create_write_transaction_message(trn_result, transient_data_encrypted, request_data_encrypted);
-                const write_transaction_message_hash = write_transaction_message.GetHash().Visualize();
-                this.waitlist.add([new MessageDependency(write_transaction_message_hash)], this.process_transaction_result.bind(this, trn_result));
-                this.send_to_adapt_wrapper(write_transaction_message);
-                logging.debug("write transaction message:", new LazyMessage(() => write_transaction_message.Visualize()));
-            }
-            else {
-                this.process_transaction_result(trn_result);
-            }
-        }
-        finally {
-            // The local builder owns only this call's transients (entropy, time,
-            // envelope, transient data). trn_result and write_transaction_message
-            // are Detach()ed and outlive this scope, so finalizing here is safe.
-            builder.Destroy();
-        }
-    }
-    process_transaction_result(message) {
-        AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            logging.info("Processing transaction result:", message.Visualize());
-            logging.info("Container state before transaction:", builder.Attach(this.packet.GetHash()).Visualize());
-            builder.Attach(message);
-            const transaction_result = Protocol.GetTransactionResultKind(message);
-            const result = message.Reduce(Protocol.FieldName.result);
-            if (transaction_result === 'SUC') {
-                if (this.packet.lifetime == this.builder.lifetime || !this.packet.lifetime)
-                    this.packet.Destroy();
-                this.packet = message.GetPacket().Clone(this.builder.lifetime);
-                logging.info("Packet state updated. New state: ", builder.Attach(this.packet.GetHash()).Visualize());
-                let idx = 0;
-                let value;
-                while (!(value = result.Reduce(idx)).IsNil()) {
-                    idx++;
-                    const action_kind = value.Reduce(Protocol.FieldName.action_kind).Visualize();
-                    if (action_kind === "RET") {
-                        if (this.packet.lifetime == this.builder.lifetime || !this.packet.lifetime)
-                            this.packet.Destroy();
-                        if (this.control_packet) {
-                            const packet = message.GetPacket().Clone(this.builder.lifetime);
-                            this.control_packet.on_message(value.Reduce(Protocol.FieldName.data).Detach(), cb => {
-                                this.packet = packet;
-                                logging.info("Packet state updated. New state: ", this.packet.GetHash().Visualize());
-                                if (cb)
-                                    cb();
-                                this.pending_transactions.resume();
-                            });
-                            return;
-                        }
-                        this.packet = message.GetPacket().Clone(this.builder.lifetime);
-                        logging.info("Packet state updated. New state: ", builder.Attach(this.packet.GetHash()).Visualize());
-                        // Give the callback a packet on a scratch lifetime we finalize right
-                        // after it returns. If the handler ignores the 2nd arg, the scratch frees
-                        // the clone; if it re-homes it (Attach to its own scope), the clone is
-                        // detached from the scratch so Finalize is a no-op and the handler owns
-                        // it. Either way no leak, and the wrapper's this.packet is never exposed.
-                        if (this.#on_return_data) {
-                            const ret_scope = new AdaptObjectLifetime();
-                            this.#on_return_data(value.Reduce(Protocol.FieldName.data).Detach(), this.packet.Clone(ret_scope));
-                            ret_scope.Finalize();
-                        }
-                    }
-                    else if (action_kind === "SEND") {
-                        this.send_to_adapt_wrapper(Protocol.CreateTransactionMessageFromEnvelope(value.Reduce(Protocol.FieldName.data)));
-                    }
-                    else if (action_kind === "VER") {
-                        if (this.#on_verify_request)
-                            this.#on_verify_request(value.Reduce(Protocol.FieldName.data).Detach());
-                    }
-                    else if (action_kind === "TIMEOUT") {
-                        const data = value.Reduce(Protocol.FieldName.data);
-                        const seconds = data.Reduce('seconds').GetNumber();
-                        const continuation_id = data.Reduce('continuation_id').Visualize();
-                        logging.debug("Recieved timeout request. Seconds: ", seconds, "continuation id: ", continuation_id);
-                        const on_timeout = () => {
-                            logging.debug("Calling timeout callback.");
-                            this.pending_transactions.push({
-                                trn: object_to_adapt_value({ name: "::continuation::continue_transaction", targ: { id: continuation_id, args: false } }).Detach(),
-                                is_user_transaction: true
-                            });
-                        };
-                        setTimeout(on_timeout.bind(this), seconds * 1000);
-                    }
-                    else {
-                        logging.error("Received invalid transaction action: ", action_kind);
-                        continue;
-                    }
-                }
-                this.pending_transactions.resume();
-            }
-            else if (transaction_result === 'FAIL') {
-                throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Invalid transaction result. Fail wasn't expected here. It should be handled before");
-            }
-            else {
-                throw new AdaptProtocolError(AdaptProtocolErrorType.INTERNAL_ERROR, "Unexpected transaction result: " + transaction_result + ". Transaction result should be checked before.");
-            }
-        });
-    }
-    //----------------------------- browser only methods ---------------------------------------
-    set on_verify_request(new_value) {
-        this.#on_verify_request = new_value;
-    }
-    set on_return_data(new_value) {
-        this.#on_return_data = new_value;
-    }
-    set on_transaction_failure(new_value) {
-        this.#on_transaction_failure = new_value;
-    }
-    acceptVerificationRequest(id) {
-        AdaptObjectBuilder.execute_and_collect_garbage(builder => {
-            const message = object_to_adapt_value({ name: "::verification::accept", targ: builder.Attach(object_to_adapt_value({ id: id })) });
-            this.add_client_message(message);
-        });
-    }
-}
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "create_create_packet_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "create_write_snapshot_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "load_attestation_document", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "create_registration_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "add_client_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "on_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "send_to_adapt_wrapper", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "flush_pending_messages_for", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "send_to_adapt_wrappper_impl", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "on_first_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "on_client_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "worker", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "first_or_client_message_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "incoming_message_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "b2w_reg_ok_v1_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "d2w_write_transaction_confirm_v1_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "d2w_write_snapshot_confirm_v1_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "d2w_create_packet_confirm_v1_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "process_confirmation_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "b2w_exec_transaction_v1_handler", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "pending_transactions_worker", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "create_write_transaction_message", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "execute_transaction", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "process_transaction_result", null);
-__decorate([
-    log_fn_call(adapt_packet_wrapper_impl_logger_proxy)
-], AdaptPacketWrapperImpl.prototype, "acceptVerificationRequest", null);
-//# sourceMappingURL=adapt_packet_wrapper_impl.js.map