@sentio/sdk 1.36.3-rc.1 → 1.36.4-rc.1

package/lib/service.js

@@ -3,45 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessorServiceImpl = void 0;
+exports.errorString = exports.mergeProcessResults = exports.Utf8ArrayToStr = exports.ProcessorServiceImpl = exports.USER_PROCESSOR = exports.DEFAULT_MAX_BLOCK = void 0;
 const nice_grpc_1 = require("nice-grpc");
-const chain_1 = require("./utils/chain");
 const gen_1 = require("./gen");
 const long_1 = __importDefault(require("long"));
 const meter_1 = require("./core/meter");
 const exporter_1 = require("./core/exporter");
 const event_tracker_1 = require("./core/event-tracker");
-const aptos_processor_1 = require("./aptos/aptos-processor");
-const account_processor_1 = require("./core/account-processor");
-const sui_processor_1 = require("./core/sui-processor");
-const solana_processor_1 = require("./core/solana-processor");
-const binds_1 = require("./binds");
 const base_processor_template_1 = require("./core/base-processor-template");
-const numberish_1 = require("./core/numberish");
+// (Long.prototype as any).toBigInt = function() {
+//   return BigInt(this.toString())
+// };
+const plugin_1 = require("./plugin");
 BigInt.prototype.toJSON = function () {
     return this.toString();
 };
-const DEFAULT_MAX_BLOCK = long_1.default.ZERO;
-const USER_PROCESSOR = 'user_processor';
+exports.DEFAULT_MAX_BLOCK = long_1.default.ZERO;
+exports.USER_PROCESSOR = 'user_processor';
 class ProcessorServiceImpl {
-    // eth handlers
-    eventHandlers = [];
-    traceHandlers = [];
-    blockHandlers = [];
-    // aptos handlers
-    aptosEventHandlers = [];
-    aptosCallHandlers = [];
-    aptosResourceHandlers = [];
-    // map from chain id to list of processors
-    // private blockHandlers = new Map<string, ((block: Block) => Promise<ProcessResult>)[]>()
-    // private processorsByChainId = new Map<string, BaseProcessor<BaseContract, BoundContractView<BaseContract, any>>>()
     started = false;
-    contractConfigs;
-    accountConfigs;
-    templateInstances;
-    metricConfigs;
-    eventTrackingConfigs;
-    exportConfigs;
+    processorConfig;
     loader;
     shutdownHandler;
     constructor(loader, shutdownHandler) {
@@ -52,36 +33,23 @@ class ProcessorServiceImpl {
         if (!this.started) {
             throw new nice_grpc_1.ServerError(nice_grpc_1.Status.UNAVAILABLE, 'Service Not started.');
         }
-        return {
-            // TODO project setting
-            config: undefined,
-            contractConfigs: this.contractConfigs,
-            accountConfigs: this.accountConfigs,
-            templateInstances: this.templateInstances,
-            eventTrackingConfigs: this.eventTrackingConfigs,
-            metricConfigs: this.metricConfigs,
-            exportConfigs: this.exportConfigs,
-        };
+        if (!this.processorConfig) {
+            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'Process config empty.');
+        }
+        return this.processorConfig;
     }
     async configure() {
-        this.eventHandlers = [];
-        this.templateInstances = [];
-        // this.processorsByChainId.clear()
-        this.contractConfigs = [];
-        this.accountConfigs = [];
+        this.processorConfig = gen_1.ProcessConfigResponse.fromPartial({});
         // This syntax is to copy values instead of using references
-        this.templateInstances = [...base_processor_template_1.TemplateInstanceState.INSTANCE.getValues()];
-        this.eventTrackingConfigs = [];
-        this.metricConfigs = [];
-        this.exportConfigs = [];
+        this.processorConfig.templateInstances = [...base_processor_template_1.TemplateInstanceState.INSTANCE.getValues()];
         // part 0, prepare metrics and event tracking configs
         for (const metric of meter_1.MetricState.INSTANCE.getValues()) {
-            this.metricConfigs.push({
+            this.processorConfig.metricConfigs.push({
                 ...metric.config,
             });
         }
         for (const eventTracker of event_tracker_1.EventTrackerState.INSTANCE.getValues()) {
-            this.eventTrackingConfigs.push({
+            this.processorConfig.eventTrackingConfigs.push({
                 distinctAggregationByDays: eventTracker.options.distinctByDays || [],
                 eventName: eventTracker.name,
                 retentionConfig: undefined,
@@ -91,261 +59,30 @@ class ProcessorServiceImpl {
             });
         }
         for (const exporter of exporter_1.ExporterState.INSTANCE.getValues()) {
-            this.exportConfigs.push({
+            this.processorConfig.exportConfigs.push({
                 name: exporter.name,
                 channel: exporter.channel,
             });
         }
-        // Part 1.a, prepare EVM processors
-        for (const processor of binds_1.ProcessorState.INSTANCE.getValues()) {
-            // If server favor incremental update this need to change
-            // Start basic config for contract
-            const chainId = processor.getChainId();
-            // this.processorsByChainId.set(chainId, processor)
-            const contractConfig = {
-                processorType: USER_PROCESSOR,
-                contract: {
-                    name: processor.config.name,
-                    chainId: chainId.toString(),
-                    address: processor.config.address,
-                    abi: '',
-                },
-                intervalConfigs: [],
-                logConfigs: [],
-                traceConfigs: [],
-                startBlock: processor.config.startBlock,
-                endBlock: DEFAULT_MAX_BLOCK,
-                instructionConfig: undefined,
-                aptosEventConfigs: [],
-                aptosCallConfigs: [],
-            };
-            if (processor.config.endBlock) {
-                contractConfig.endBlock = processor.config.endBlock;
-            }
-            // Step 1. Prepare all the block handlers
-            for (const blockHandler of processor.blockHandlers) {
-                const handlerId = this.blockHandlers.push(blockHandler.handler) - 1;
-                // TODO wrap the block handler into one
-                contractConfig.intervalConfigs.push({
-                    slot: 0,
-                    slotInterval: blockHandler.blockInterval,
-                    minutes: 0,
-                    minutesInterval: blockHandler.timeIntervalInMinutes,
-                    handlerId: handlerId,
-                });
-            }
-            // Step 2. Prepare all trace handlers
-            for (const traceHandler of processor.traceHandlers) {
-                const handlerId = this.traceHandlers.push(traceHandler.handler) - 1;
-                contractConfig.traceConfigs.push({
-                    signature: traceHandler.signature,
-                    handlerId: handlerId,
-                });
-            }
-            // Step 3. Prepare all the event handlers
-            for (const eventsHandler of processor.eventHandlers) {
-                // associate id with filter
-                const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1;
-                const logConfig = {
-                    handlerId: handlerId,
-                    filters: [],
-                };
-                for (const filter of eventsHandler.filters) {
-                    if (!filter.topics) {
-                        throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'Topic should not be null');
-                    }
-                    const logFilter = {
-                        addressType: undefined,
-                        address: contractConfig.contract?.address,
-                        topics: [],
-                    };
-                    for (const ts of filter.topics) {
-                        let hashes = [];
-                        if (Array.isArray(ts)) {
-                            hashes = hashes.concat(ts);
-                        }
-                        else if (ts) {
-                            hashes.push(ts);
-                        }
-                        logFilter.topics.push({ hashes: hashes });
-                    }
-                    logConfig.filters.push(logFilter);
-                }
-                contractConfig.logConfigs.push(logConfig);
-            }
-            // Finish up a contract
-            this.contractConfigs.push(contractConfig);
-        }
-        // part 1.b prepare EVM account processors
-        for (const processor of account_processor_1.AccountProcessorState.INSTANCE.getValues()) {
-            const accountConfig = {
-                address: processor.config.address,
-                chainId: processor.getChainId().toString(),
-                startBlock: processor.config.startBlock ? long_1.default.fromValue(processor.config.startBlock) : long_1.default.ZERO,
-                aptosIntervalConfigs: [],
-                intervalConfigs: [],
-                logConfigs: [],
-            };
-            // TODO add interval
-            for (const eventsHandler of processor.eventHandlers) {
-                // associate id with filter
-                const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1;
-                const logConfig = {
-                    handlerId: handlerId,
-                    filters: [],
-                };
-                for (const filter of eventsHandler.filters) {
-                    if (!filter.topics) {
-                        throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'Topic should not be null');
-                    }
-                    const logFilter = {
-                        addressType: filter.addressType,
-                        address: filter.address,
-                        topics: [],
-                    };
-                    for (const ts of filter.topics) {
-                        let hashes = [];
-                        if (Array.isArray(ts)) {
-                            hashes = hashes.concat(ts);
-                        }
-                        else if (ts) {
-                            hashes.push(ts);
-                        }
-                        logFilter.topics.push({ hashes: hashes });
-                    }
-                    logConfig.filters.push(logFilter);
-                }
-                accountConfig.logConfigs.push(logConfig);
-            }
-            this.accountConfigs.push(accountConfig);
-        }
-        // Part 2, prepare solana constractors
-        for (const solanaProcessor of solana_processor_1.SolanaProcessorState.INSTANCE.getValues()) {
-            const contractConfig = {
-                processorType: USER_PROCESSOR,
-                contract: {
-                    name: solanaProcessor.contractName,
-                    chainId: solanaProcessor.network,
-                    address: solanaProcessor.address,
-                    abi: '',
-                },
-                logConfigs: [],
-                traceConfigs: [],
-                intervalConfigs: [],
-                startBlock: solanaProcessor.config.startSlot,
-                endBlock: DEFAULT_MAX_BLOCK,
-                instructionConfig: {
-                    innerInstruction: solanaProcessor.processInnerInstruction,
-                    parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
-                    rawDataInstruction: solanaProcessor.decodeInstruction !== null,
-                },
-                aptosEventConfigs: [],
-                aptosCallConfigs: [],
-            };
-            this.contractConfigs.push(contractConfig);
-        }
-        // Part 3, prepare sui constractors
-        for (const suiProcessor of sui_processor_1.SuiProcessorState.INSTANCE.getValues()) {
-            const contractConfig = {
-                processorType: USER_PROCESSOR,
-                contract: {
-                    name: 'sui contract',
-                    chainId: chain_1.CHAIN_IDS.SUI_DEVNET,
-                    address: suiProcessor.address,
-                    abi: '',
-                },
-                logConfigs: [],
-                intervalConfigs: [],
-                traceConfigs: [],
-                startBlock: suiProcessor.config.startSeqNumber,
-                endBlock: DEFAULT_MAX_BLOCK,
-                instructionConfig: undefined,
-                aptosEventConfigs: [],
-                aptosCallConfigs: [],
-            };
-            this.contractConfigs.push(contractConfig);
-        }
-        // Part 4, prepare aptos constractors
-        for (const aptosProcessor of aptos_processor_1.AptosProcessorState.INSTANCE.getValues()) {
-            const contractConfig = {
-                processorType: USER_PROCESSOR,
-                contract: {
-                    name: aptosProcessor.moduleName,
-                    chainId: aptosProcessor.getChainId(),
-                    address: aptosProcessor.config.address,
-                    abi: '',
-                },
-                intervalConfigs: [],
-                logConfigs: [],
-                traceConfigs: [],
-                startBlock: long_1.default.fromString(aptosProcessor.config.startVersion.toString()),
-                endBlock: DEFAULT_MAX_BLOCK,
-                instructionConfig: undefined,
-                aptosEventConfigs: [],
-                aptosCallConfigs: [],
-            };
-            // 1. Prepare event handlers
-            for (const handler of aptosProcessor.eventHandlers) {
-                const handlerId = this.aptosEventHandlers.push(handler.handler) - 1;
-                const eventHandlerConfig = {
-                    filters: handler.filters.map((f) => {
-                        return {
-                            type: f.type,
-                            account: f.account || '',
-                        };
-                    }),
-                    handlerId,
-                };
-                contractConfig.aptosEventConfigs.push(eventHandlerConfig);
-            }
-            // 2. Prepare function handlers
-            for (const handler of aptosProcessor.callHandlers) {
-                const handlerId = this.aptosCallHandlers.push(handler.handler) - 1;
-                const functionHandlerConfig = {
-                    filters: handler.filters.map((filter) => {
-                        return {
-                            function: filter.function,
-                            typeArguments: filter.typeArguments || [],
-                            withTypeArguments: filter.typeArguments ? true : false,
-                            includeFailed: filter.includeFailed || false,
-                        };
-                    }),
-                    handlerId,
-                };
-                contractConfig.aptosCallConfigs.push(functionHandlerConfig);
-            }
-            this.contractConfigs.push(contractConfig);
-        }
-        for (const aptosProcessor of aptos_processor_1.AptosAccountProcessorState.INSTANCE.getValues()) {
-            const accountConfig = {
-                address: aptosProcessor.config.address,
-                chainId: aptosProcessor.getChainId(),
-                startBlock: long_1.default.fromValue(aptosProcessor.config.startVersion.toString()),
-                aptosIntervalConfigs: [],
-                intervalConfigs: [],
-                logConfigs: [],
-            };
-            for (const handler of aptosProcessor.resourcesHandlers) {
-                const handlerId = this.aptosResourceHandlers.push(handler.handler) - 1;
-                accountConfig.aptosIntervalConfigs.push({
-                    intervalConfig: {
-                        handlerId: handlerId,
-                        minutes: 0,
-                        minutesInterval: handler.timeIntervalInMinutes,
-                        slot: 0,
-                        slotInterval: handler.versionInterval,
-                    },
-                    type: handler.type || '',
-                });
-            }
-            this.accountConfigs.push(accountConfig);
-        }
+        plugin_1.PluginManager.INSTANCE.configure(this.processorConfig);
     }
     async start(request, context) {
         if (this.started) {
             return {};
         }
         try {
+            try {
+                require('./core/eth-plugin');
+                require('./core/sui-plugin');
+                require('./aptos/aptos-plugin');
+                require('./core/solana-plugin');
+            }
+            catch (e) {
+                require('@sentio/sdk/lib/core/eth-plugin');
+                require('@sentio/sdk/lib/core/sui-plugin');
+                require('@sentio/sdk/lib/aptos/aptos-plugin');
+                require('@sentio/sdk/lib/core/solana-plugin');
+            }
             this.loader();
         }
         catch (e) {
@@ -391,7 +128,7 @@ class ProcessorServiceImpl {
         const result = mergeProcessResults(await Promise.all(promises));
         let updated = false;
         const t = base_processor_template_1.TemplateInstanceState.INSTANCE.getValues();
-        if (base_processor_template_1.TemplateInstanceState.INSTANCE.getValues().length !== this.templateInstances.length) {
+        if (base_processor_template_1.TemplateInstanceState.INSTANCE.getValues().length !== this.processorConfig.templateInstances.length) {
             await this.configure();
             updated = true;
         }
@@ -401,30 +138,7 @@ class ProcessorServiceImpl {
         };
     }
     async processBinding(request, options) {
-        const processBindingInternal = (request) => {
-            switch (request.handlerType) {
-                case gen_1.HandlerType.APT_CALL:
-                    return this.processAptosFunctionCall(request);
-                case gen_1.HandlerType.APT_EVENT:
-                    return this.processAptosEvent(request);
-                case gen_1.HandlerType.APT_RESOURCE:
-                    return this.processAptosResource(request);
-                case gen_1.HandlerType.ETH_LOG:
-                    return this.processLog(request);
-                case gen_1.HandlerType.ETH_TRACE:
-                    return this.processTrace(request);
-                case gen_1.HandlerType.ETH_BLOCK:
-                    return this.processBlock(request);
-                case gen_1.HandlerType.SOL_INSTRUCTION:
-                    return this.processSolInstruction(request);
-                // TODO migrate SUI cases
-                // case HandlerType.INSTRUCTION:
-                //   return this.processInstruction(request)
-                default:
-                    throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType);
-            }
-        };
-        const result = await processBindingInternal(request);
+        const result = await plugin_1.PluginManager.INSTANCE.processBinding(request);
         recordRuntimeInfo(result, request.handlerType);
         return result;
     }
@@ -432,7 +146,7 @@ class ProcessorServiceImpl {
         for await (const request of requests) {
             const result = await this.processBinding(request);
             let updated = false;
-            if (base_processor_template_1.TemplateInstanceState.INSTANCE.getValues().length !== this.templateInstances.length) {
+            if (base_processor_template_1.TemplateInstanceState.INSTANCE.getValues().length !== this.processorConfig.templateInstances.length) {
                 await this.configure();
                 updated = true;
             }
@@ -442,173 +156,6 @@ class ProcessorServiceImpl {
             };
         }
     }
-    async processLog(request) {
-        if (!request.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Log can't be null");
-        }
-        const promises = [];
-        let log;
-        if (request.data.ethLog) {
-            log = request.data.ethLog.log;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(request.data.raw);
-            log = JSON.parse(jsonString);
-        }
-        for (const handlerId of request.handlerIds) {
-            const handler = this.eventHandlers[handlerId];
-            promises.push(handler(log).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing log: ' + JSON.stringify(log) + '\n' + errorString(e));
-            }));
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processSolInstruction(request) {
-        if (!request.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'instruction data cannot be empty');
-        }
-        const instruction = request.data.solInstruction || gen_1.Data_SolInstruction.decode(request.data.raw); // JSON.parse(jsonString)
-        const promises = [];
-        // Only have instruction handlers for solana processors
-        for (const processor of solana_processor_1.SolanaProcessorState.INSTANCE.getValues()) {
-            if (processor.address === instruction.programAccountId) {
-                let parsedInstruction = null;
-                if (instruction.parsed) {
-                    parsedInstruction = processor.getParsedInstruction(instruction.parsed);
-                }
-                else if (instruction.instructionData) {
-                    parsedInstruction = processor.getParsedInstruction(instruction.instructionData);
-                }
-                if (parsedInstruction == null) {
-                    continue;
-                }
-                const insHandler = processor.getInstructionHandler(parsedInstruction);
-                if (insHandler == null) {
-                    continue;
-                }
-                const res = await processor.handleInstruction(parsedInstruction, instruction.accounts, insHandler, instruction.slot);
-                promises.push(Promise.resolve(res));
-            }
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processBlock(binding) {
-        if (!binding.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Block can't be empty");
-        }
-        let block;
-        if (binding.data.ethBlock?.block) {
-            block = binding.data.ethBlock.block;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(binding.data.raw);
-            block = JSON.parse(jsonString);
-        }
-        const promises = [];
-        for (const handlerId of binding.handlerIds) {
-            promises.push(this.blockHandlers[handlerId](block).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing block: ' + block.number + '\n' + errorString(e));
-            }));
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processTrace(binding) {
-        if (!binding.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Trace can't be empty");
-        }
-        let trace;
-        if (binding.data.ethTrace?.trace) {
-            trace = binding.data.ethTrace.trace;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(binding.data.raw);
-            trace = JSON.parse(jsonString);
-        }
-        const promises = [];
-        for (const handlerId of binding.handlerIds) {
-            promises.push(this.traceHandlers[handlerId](trace).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing trace: ' + JSON.stringify(trace) + '\n' + errorString(e));
-            }));
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processAptosEvent(binding) {
-        if (!binding.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Event can't be empty");
-        }
-        const promises = [];
-        let event;
-        if (binding.data.aptEvent?.event) {
-            event = binding.data.aptEvent?.event;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(binding.data.raw);
-            event = JSON.parse(jsonString);
-        }
-        for (const handlerId of binding.handlerIds) {
-            // only support aptos event for now
-            promises.push(this.aptosEventHandlers[handlerId](event).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e));
-            }));
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processAptosResource(binding) {
-        if (!binding.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Event can't be empty");
-        }
-        const resource = {
-            resources: [],
-            version: 0n,
-            timestamp: 0,
-        };
-        if (binding.data.aptResource?.resources) {
-            if (binding.data.aptResource.timestampMicros.greaterThan(Number.MAX_SAFE_INTEGER)) {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'timestamp is too large');
-            }
-            resource.timestamp = binding.data.aptResource.timestampMicros.toNumber();
-            resource.version = (0, numberish_1.toBigInt)(binding.data.aptResource.version);
-            resource.resources = binding.data.aptResource.resources;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(binding.data.raw);
-            const json = JSON.parse(jsonString);
-            if (long_1.default.fromString(json.timestamp).greaterThan(Number.MAX_SAFE_INTEGER)) {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, 'timestamp is too large');
-            }
-            resource.timestamp = parseInt(json.timestamp);
-            resource.version = (0, numberish_1.toBigInt)(json.version);
-        }
-        const promises = [];
-        for (const handlerId of binding.handlerIds) {
-            promises.push(this.aptosResourceHandlers[handlerId](resource).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing event: ' + JSON.stringify(resource) + '\n' + errorString(e));
-            }));
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
-    async processAptosFunctionCall(binding) {
-        if (!binding.data) {
-            throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INVALID_ARGUMENT, "Event can't be empty");
-        }
-        let call;
-        if (binding.data.aptCall?.call) {
-            call = binding.data.aptCall?.call;
-        }
-        else {
-            const jsonString = Utf8ArrayToStr(binding.data.raw);
-            call = JSON.parse(jsonString);
-        }
-        const promises = [];
-        for (const handlerId of binding.handlerIds) {
-            // only support aptos call for now
-            const promise = this.aptosCallHandlers[handlerId](call).catch((e) => {
-                throw new nice_grpc_1.ServerError(nice_grpc_1.Status.INTERNAL, 'error processing call: ' + JSON.stringify(call) + '\n' + errorString(e));
-            });
-            promises.push(promise);
-        }
-        return mergeProcessResults(await Promise.all(promises));
-    }
 }
 exports.ProcessorServiceImpl = ProcessorServiceImpl;
 // https://ourcodeworld.com/articles/read/164/how-to-convert-an-uint8array-to-string-in-javascript
@@ -649,6 +196,7 @@ function Utf8ArrayToStr(array) {
     }
     return out;
 }
+exports.Utf8ArrayToStr = Utf8ArrayToStr;
 function mergeProcessResults(results) {
     const res = gen_1.ProcessResult.fromPartial({});
     for (const r of results) {
@@ -660,6 +208,7 @@ function mergeProcessResults(results) {
     }
     return res;
 }
+exports.mergeProcessResults = mergeProcessResults;
 function recordRuntimeInfo(results, handlerType) {
     for (const list of [results.gauges, results.counters, results.logs, results.events, results.exports]) {
         list.forEach((e) => {
@@ -672,4 +221,5 @@ function recordRuntimeInfo(results, handlerType) {
 function errorString(e) {
     return e.stack || e.message;
 }
+exports.errorString = errorString;
 //# sourceMappingURL=service.js.map