@aztec/foundation 0.1.0-alpha10

package/src/running-promise/index.ts

@@ -0,0 +1,60 @@
+/**
+ * RunningPromise is a utility class that helps manage the execution of an asynchronous function
+ * at a specified polling interval. It allows starting, stopping, and checking the status of the
+ * internally managed promise. The class also supports interrupting the polling process when stopped.
+ */
+export class RunningPromise {
+  private running = false;
+  private runningPromise = Promise.resolve();
+  private interruptPromise = Promise.resolve();
+  private interruptResolve = () => {};
+  constructor(private fn: () => Promise<void>, private pollingInterval = 10000) {}
+
+  /**
+   * Starts the running promise.
+   */
+  public start() {
+    this.running = true;
+    this.interruptPromise = new Promise(resolve => (this.interruptResolve = resolve));
+
+    const poll = async () => {
+      while (this.running) {
+        await this.fn();
+        await this.interruptableSleep(this.pollingInterval);
+      }
+    };
+    this.runningPromise = poll();
+  }
+
+  /**
+   * Stops the running promise, resolves any pending interruptable sleep,
+   * and waits for the currently executing function to complete.
+   */
+  async stop(): Promise<void> {
+    this.running = false;
+    this.interruptResolve();
+    await this.runningPromise;
+  }
+
+  /**
+   * A sleep function that can be interrupted before the specified time.
+   * The sleep duration is determined by 'timeInMs', and it can be terminated early if the 'interruptPromise' is resolved.
+   * @param timeInMs - The time in milliseconds.
+   */
+  private async interruptableSleep(timeInMs: number) {
+    let timeout!: NodeJS.Timeout;
+    const sleepPromise = new Promise(resolve => {
+      timeout = setTimeout(resolve, timeInMs);
+    });
+    await Promise.race([sleepPromise, this.interruptPromise]);
+    clearTimeout(timeout);
+  }
+
+  /**
+   * Checks if the running promise is currently active.
+   * @returns True if the promise is running.
+   */
+  public isRunning() {
+    return this.running;
+  }
+}

package/src/serialize/buffer_reader.test.ts

@@ -0,0 +1,175 @@
+import { jest } from '@jest/globals';
+import { Fq, Fr } from '../fields/fields.js';
+import { BufferReader } from './buffer_reader.js';
+import { serializeBufferArrayToVector } from './free_funcs.js';
+import { randomBytes } from '../crypto/index.js';
+
+const ARRAY = Array.from(Array(32)).map((_, idx) => (idx % 2 === 0 ? 0 : 1));
+const BUFFER = Buffer.from(ARRAY);
+const NUMBER = 65537;
+const sizes = [16, 48, 32];
+
+describe('buffer reader', () => {
+  let bufferReader: BufferReader;
+
+  beforeEach(() => {
+    bufferReader = new BufferReader(BUFFER);
+  });
+
+  describe('readNumber', () => {
+    it('should return number', () => {
+      expect(bufferReader.readNumber()).toBe(NUMBER);
+    });
+  });
+
+  describe('readBoolean', () => {
+    it('should read true when 1 and false when 0', () => {
+      ARRAY.forEach(element => {
+        if (element !== 0) {
+          expect(bufferReader.readBoolean()).toBe(true);
+        } else {
+          expect(bufferReader.readBoolean()).toBe(false);
+        }
+      });
+    });
+  });
+
+  describe('readBytes', () => {
+    it('should read buffer by slices', () => {
+      expect(bufferReader.readBytes(2)).toEqual(Buffer.from(ARRAY.slice(0, 2)));
+      expect(bufferReader.readBytes(3)).toEqual(Buffer.from(ARRAY.slice(2, 5)));
+    });
+  });
+
+  describe('readFr', () => {
+    it('should get Fr from buffer', () => {
+      expect(bufferReader.readFr()).toEqual(Fr.fromBuffer(BUFFER));
+    });
+  });
+
+  describe('readFq', () => {
+    it('should get Fq from buffer', () => {
+      expect(bufferReader.readFq()).toEqual(Fq.fromBuffer(BUFFER));
+    });
+  });
+
+  describe('readNumberVector', () => {
+    let vectorBufferReader: BufferReader;
+
+    beforeEach(() => {
+      const uintArr = [7, 13, 16];
+      const uintBufArr = uintArr.map(num => {
+        const uintBuf = Buffer.alloc(4);
+        uintBuf.writeUInt32BE(num, 0);
+        return uintBuf;
+      });
+      const uintArrVec = serializeBufferArrayToVector(uintBufArr);
+      vectorBufferReader = new BufferReader(uintArrVec);
+    });
+
+    it('should read number vector', () => {
+      expect(vectorBufferReader.readNumberVector()).toEqual([7, 13, 16]);
+    });
+  });
+
+  describe('readVector', () => {
+    it('should read vector and generate result array', () => {
+      const fn = jest.fn();
+      let i = -1;
+      const result = bufferReader.readVector({
+        fromBuffer: () => {
+          fn();
+          i++;
+          return i;
+        },
+      });
+      expect(result.length).toBe(NUMBER);
+      expect(result).toEqual(Array.from(Array(NUMBER).keys()));
+      expect(fn).toHaveBeenCalledTimes(NUMBER);
+    });
+  });
+
+  describe('readArray', () => {
+    it('should read array from buffer', () => {
+      const fn = jest.fn();
+      let i = -1;
+      expect(
+        bufferReader.readArray(10, {
+          fromBuffer: () => {
+            fn();
+            i++;
+            return i;
+          },
+        }),
+      ).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    });
+  });
+
+  describe('readBufferArray', () => {
+    it('should read variable length array from buffer', () => {
+      // Testing `readBufferArray` with a buffer that ONLY contains the data that will be read.
+      // No `size` variable is passed in this case.
+      const bufferArray: Buffer[] = [];
+      let buf = Buffer.alloc(0);
+      for (const size of sizes) {
+        const sizeBuf = Buffer.alloc(4);
+        sizeBuf.writeUInt32BE(size);
+        const bytes = randomBytes(size);
+        const ranBuf = Buffer.concat([sizeBuf, bytes]);
+        bufferArray.push(bytes);
+        buf = Buffer.concat([buf, ranBuf]);
+      }
+      const reader = BufferReader.asReader(buf);
+      const res = reader.readBufferArray();
+      expect(res).toEqual(bufferArray);
+    });
+
+    it('should read variable length array from buffer with other contents', () => {
+      // testing `readBufferArray` with a buffer that includes some other data before and after the data that will be read.
+      // The `size` variable needs to be passed in this case.
+      const bufferArray: Buffer[] = [];
+      const prefixBytes = randomBytes(32);
+      const postfixBytes = randomBytes(16);
+      let bufLen = 0;
+      let buf = Buffer.alloc(32, prefixBytes);
+      for (const size of sizes) {
+        const sizeBuf = Buffer.alloc(4);
+        sizeBuf.writeUInt32BE(size);
+
+        const bytes = randomBytes(size);
+        const ranBuf = Buffer.concat([sizeBuf, bytes]);
+        buf = Buffer.concat([buf, ranBuf]);
+
+        bufferArray.push(bytes);
+        bufLen += ranBuf.length;
+      }
+      buf = Buffer.concat([buf, postfixBytes]);
+      const reader = BufferReader.asReader(buf);
+      const preRes = reader.readBytes(prefixBytes.length);
+      expect(preRes).toEqual(prefixBytes);
+      expect(reader.readBufferArray(bufLen)).toEqual(bufferArray);
+      expect(reader.readBytes(postfixBytes.length)).toEqual(postfixBytes);
+    });
+  });
+
+  describe('readObject', () => {
+    it('should read object from buffer', () => {
+      const fn = jest.fn();
+      const object = bufferReader.readObject({
+        fromBuffer: (reader: BufferReader) => {
+          fn();
+          return { value: 'test-string', buffer: reader };
+        },
+      });
+      expect(object.value).toEqual('test-string');
+      expect(object.buffer).toEqual(bufferReader);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('peekBytes', () => {
+    it('should return bytes from buffer', () => {
+      expect(bufferReader.peekBytes(10)).toEqual(Buffer.from(ARRAY.slice(0, 10)));
+    });
+  });
+});

package/src/serialize/buffer_reader.ts

@@ -0,0 +1,272 @@
+import { Fr, Fq } from '../fields/fields.js';
+import { Tuple } from './types.js';
+
+/**
+ * The BufferReader class provides a utility for reading various data types from a buffer.
+ * It supports reading numbers, booleans, byte arrays, Fr and Fq field elements,
+ * vectors, arrays, objects, strings, and maps. It maintains an internal index to
+ * keep track of the current reading position in the buffer.
+ *
+ * Usage:
+ * Create a new instance of BufferReader with a buffer and an optional offset.
+ * Use the provided methods to read desired data types from the buffer.
+ * The reading methods automatically advance the internal index.
+ *
+ * @example
+ * const reader = new BufferReader(someBuffer);
+ * const num = reader.readNumber();
+ * const bool = reader.readBoolean();
+ * const byteArray = reader.readBytes(4);
+ */
+export class BufferReader {
+  private index: number;
+  constructor(private buffer: Buffer, offset = 0) {
+    this.index = offset;
+  }
+
+  /**
+   * Creates a BufferReader instance from either a Buffer or an existing BufferReader.
+   * If the input is a Buffer, it creates a new BufferReader with the given buffer.
+   * If the input is already a BufferReader, it returns the input unchanged.
+   *
+   * @param bufferOrReader - A Buffer or BufferReader to initialize the BufferReader.
+   * @returns An instance of BufferReader.
+   */
+  public static asReader(bufferOrReader: Buffer | BufferReader) {
+    return Buffer.isBuffer(bufferOrReader) ? new BufferReader(bufferOrReader) : bufferOrReader;
+  }
+
+  /**
+   * Reads a 32-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 4 bytes after reading the number.
+   *
+   * @returns The read 32-bit unsigned integer value.
+   */
+  public readNumber(): number {
+    this.index += 4;
+    return this.buffer.readUint32BE(this.index - 4);
+  }
+
+  /**
+   * Reads a 16-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 2 bytes after reading the number.
+   *
+   * @returns The read 16 bit value.
+   */
+  public readUInt16(): number {
+    this.index += 2;
+    return this.buffer.readUInt16BE(this.index - 2);
+  }
+
+  /**
+   * Reads and returns the next boolean value from the buffer.
+   * Advances the internal index by 1, treating the byte at the current index as a boolean value.
+   * Returns true if the byte is non-zero, false otherwise.
+   *
+   * @returns A boolean value representing the byte at the current index.
+   */
+  public readBoolean(): boolean {
+    this.index += 1;
+    return Boolean(this.buffer.at(this.index - 1));
+  }
+
+  /**
+   * Reads a specified number of bytes from the buffer and returns a new Buffer containing those bytes.
+   * Advances the reader's index by the number of bytes read. Throws an error if there are not enough
+   * bytes left in the buffer to satisfy the requested number of bytes.
+   *
+   * @param n - The number of bytes to read from the buffer.
+   * @returns A new Buffer containing the read bytes.
+   */
+  public readBytes(n: number): Buffer {
+    this.index += n;
+    return Buffer.from(this.buffer.subarray(this.index - n, this.index));
+  }
+
+  /**
+   * Reads a Fr (finite field) element from the buffer using the 'fromBuffer' method of the Fr class.
+   * The Fr class should provide a 'fromBuffer' method that takes a BufferReader instance as input.
+   *
+   * @returns An instance of the Fr class representing the finite field element.
+   */
+  public readFr(): Fr {
+    return Fr.fromBuffer(this);
+  }
+
+  /**
+   * Reads the next Fq element from the buffer using the Fq.fromBuffer method.
+   * The Fq element represents a finite field in elliptic curve cryptography and is used for calculations.
+   * Advances the internal buffer index by the number of bytes read.
+   *
+   * @returns An Fq instance representing the finite field element.
+   */
+  public readFq(): Fq {
+    return Fq.fromBuffer(this);
+  }
+
+  /**
+   * Reads a vector of numbers from the buffer and returns it as an array of numbers.
+   * The method utilizes the 'readVector' method, passing a deserializer that reads numbers.
+   *
+   * @returns An array of numbers representing the vector read from the buffer.
+   */
+  public readNumberVector(): number[] {
+    return this.readVector({
+      fromBuffer: (reader: BufferReader) => reader.readNumber(),
+    });
+  }
+
+  /**
+   * Reads a vector of fixed size from the buffer and deserializes its elements using the provided itemDeserializer object.
+   * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance and returns the deserialized element.
+   * The method first reads the size of the vector (a number) from the buffer, then iterates through its elements,
+   * deserializing each one using the 'fromBuffer' method of 'itemDeserializer'.
+   *
+   * @param itemDeserializer - Object with 'fromBuffer' method to deserialize vector elements.
+   * @returns An array of deserialized elements of type T.
+   */
+  public readVector<T>(itemDeserializer: {
+    /**
+     * A method to deserialize data from a buffer.
+     */
+    fromBuffer: (reader: BufferReader) => T;
+  }): T[] {
+    const size = this.readNumber();
+    const result = new Array<T>(size);
+    for (let i = 0; i < size; i++) {
+      result[i] = itemDeserializer.fromBuffer(this);
+    }
+    return result;
+  }
+
+  /**
+   * Read an array of a fixed size with elements of type T from the buffer.
+   * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance as input,
+   * and returns an instance of the desired deserialized data type T.
+   * This method will call the 'fromBuffer' method for each element in the array and return the resulting array.
+   *
+   * @param size - The fixed number of elements in the array.
+   * @param itemDeserializer - An object with a 'fromBuffer' method to deserialize individual elements of type T.
+   * @returns An array of instances of type T.
+   */
+  public readArray<T, N extends number>(
+    size: N,
+    itemDeserializer: {
+      /**
+       * A function for deserializing data from a BufferReader instance.
+       */
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): Tuple<T, N> {
+    const result = Array.from({ length: size }, () => itemDeserializer.fromBuffer(this));
+    return result as Tuple<T, N>;
+  }
+
+  /**
+   * Read a variable sized Buffer array where elements are represented by length + data.
+   * The method consecutively looks for a number which is the size of the proceeding buffer,
+   * then reads the bytes until it reaches the end of the reader's internal buffer.
+   * NOTE: if `size` is not provided, this will run to the end of the reader's buffer.
+   * @param size - Size of the buffer array in bytes (full remaining buffer length if left empty).
+   * @returns An array of variable sized buffers.
+   */
+  public readBufferArray(size = -1): Buffer[] {
+    const result: Buffer[] = [];
+    const end = size >= 0 ? this.index + size : this.buffer.length;
+    while (this.index < end) {
+      const item = this.readBuffer();
+      result.push(item);
+    }
+    // Ensure that all bytes have been read.
+    if (this.index !== end) {
+      throw new Error(
+        `Reader buffer was not fully consumed. Consumed up to ${this.index} bytes. End of data: ${end} bytes.`,
+      );
+    }
+    return result;
+  }
+
+  /**
+   * Reads a serialized object from a buffer and returns the deserialized object using the given deserializer.
+   *
+   * @typeparam T - The type of the deserialized object.
+   * @param deserializer - An object with a 'fromBuffer' method that takes a BufferReader instance and returns an instance of the deserialized object.
+   * @returns The deserialized object of type T.
+   */
+  public readObject<T>(deserializer: {
+    /**
+     * A method that takes a BufferReader instance and returns an instance of the deserialized data type.
+     */
+    fromBuffer: (reader: BufferReader) => T;
+  }): T {
+    return deserializer.fromBuffer(this);
+  }
+
+  /**
+   * Returns a Buffer containing the next n bytes from the current buffer without modifying the reader's index position.
+   * If n is not provided or exceeds the remaining length of the buffer, it returns all bytes from the current position till the end of the buffer.
+   *
+   * @param n - The number of bytes to peek from the current buffer. (Optional).
+   * @returns A Buffer with the next n bytes or the remaining bytes if n is not provided or exceeds the buffer length.
+   */
+  public peekBytes(n?: number): Buffer {
+    return this.buffer.subarray(this.index, n ? this.index + n : undefined);
+  }
+
+  /**
+   * Reads a string from the buffer and returns it.
+   * The method first reads the size of the string, then reads the corresponding
+   * number of bytes from the buffer and converts them to a string.
+   *
+   * @returns The read string from the buffer.
+   */
+  public readString(): string {
+    return this.readBuffer().toString();
+  }
+
+  /**
+   * Reads a buffer from the current position of the reader and advances the index.
+   * The method first reads the size (number) of bytes to be read, and then returns
+   * a Buffer with that size containing the bytes. Useful for reading variable-length
+   * binary data encoded as (size, data) format.
+   *
+   * @returns A Buffer containing the read bytes.
+   */
+  public readBuffer(): Buffer {
+    const size = this.readNumber();
+    return this.readBytes(size);
+  }
+
+  /**
+   * Reads and constructs a map object from the current buffer using the provided deserializer.
+   * The method reads the number of entries in the map, followed by iterating through each key-value pair.
+   * The key is read as a string, while the value is obtained using the passed deserializer's `fromBuffer` method.
+   * The resulting map object is returned, containing all the key-value pairs read from the buffer.
+   *
+   * @param deserializer - An object with a `fromBuffer` method to deserialize the values in the map.
+   * @returns A map object with string keys and deserialized values based on the provided deserializer.
+   */
+  public readMap<T>(deserializer: {
+    /**
+     * Deserializes an element of type T from a BufferReader instance.
+     */
+    fromBuffer: (reader: BufferReader) => T;
+  }): { [key: string]: T } {
+    const numEntries = this.readNumber();
+    const map: { [key: string]: T } = {};
+    for (let i = 0; i < numEntries; i++) {
+      const key = this.readString();
+      const value = this.readObject<T>(deserializer);
+      map[key] = value;
+    }
+    return map;
+  }
+
+  /**
+   * Get the length of the reader's buffer.
+   * @returns The length of the underlying reader's buffer.
+   */
+  public getLength(): number {
+    return this.buffer.length;
+  }
+}

package/src/serialize/deserializer.ts

@@ -0,0 +1,180 @@
+import {
+  deserializeArrayFromVector,
+  deserializeBigInt,
+  deserializeBool,
+  deserializeBufferFromVector,
+  deserializeInt32,
+  deserializeUInt32,
+} from './free_funcs.js';
+
+/**
+ * DeserializeFn is a type representing a deserialization function for a specific data type. The function takes
+ * a buffer and an offset as input, and returns an object containing the deserialized element of the data type and
+ * the number of bytes advanced in the buffer. This type is used to provide custom deserialization logic for arrays,
+ * objects or custom data types while working with the Deserializer class.
+ */
+export type DeserializeFn<T> = (
+  buf: Buffer,
+  offset: number,
+) => {
+  /**
+   * The deserialized element of the specified data type.
+   */
+  elem: T;
+  /**
+   * The number of bytes advanced in the buffer during deserialization.
+   */
+  adv: number;
+};
+
+/**
+ * Deserializer class provides a set of methods to deserialize different data types from a buffer.
+ * It maintains an internal buffer and offset, updating the offset as it deserializes each data type.
+ * The class supports deserialization of various data types including boolean, integers, big integers,
+ * buffers, strings, dates, and arrays with custom deserialization functions.
+ *
+ * @example
+ * const deserializer = new Deserializer(buffer);
+ * const boolValue = deserializer.bool();
+ * const intValue = deserializer.int32();
+ * const bigIntValue = deserializer.bigInt();
+ * const stringValue = deserializer.string();
+ * const dateValue = deserializer.date();
+ * const arrayValue = deserializer.deserializeArray(customDeserializeFn);
+ */
+export class Deserializer {
+  constructor(private buf: Buffer, private offset = 0) {}
+
+  /**
+   * Deserialize a boolean value from the buffer at the current offset.
+   * Advances the internal offset by one byte after deserialization.
+   * Returns 'true' if the deserialized value is non-zero, otherwise returns 'false'.
+   *
+   * @returns The deserialized boolean value.
+   */
+  public bool() {
+    return this.exec(deserializeBool) ? true : false;
+  }
+
+  /**
+   * Deserialize a 32-bit unsigned integer from the buffer at the current offset.
+   * Advances the internal buffer offset by 4 after successful deserialization.
+   * The result is returned as a JavaScript number.
+   *
+   * @returns A 32-bit unsigned integer value.
+   */
+  public uInt32() {
+    return this.exec(deserializeUInt32);
+  }
+
+  /**
+   * Deserialize a 32-bit signed integer from the internal buffer.
+   * Reads 4 bytes from the current offset in the buffer and interprets them as a little-endian int32 value.
+   * Advances the internal offset by 4 bytes after successful deserialization.
+   *
+   * @returns The deserialized 32-bit signed integer value.
+   */
+  public int32() {
+    return this.exec(deserializeInt32);
+  }
+
+  /**
+   * Deserialize a BigInt from the buffer, taking into account the specified width.
+   * The method reads 'width' bytes from the buffer starting at the current offset and converts it to a BigInt.
+   * The offset is advanced by 'width' bytes after successful deserialization.
+   *
+   * @param width - The number of bytes to read from the buffer to construct the BigInt (default is 32).
+   * @returns The deserialized BigInt value.
+   */
+  public bigInt(width = 32) {
+    return this.exec((buf: Buffer, offset: number) => deserializeBigInt(buf, offset, width));
+  }
+
+  /**
+   * Deserialize a variable-length byte array from the internal buffer.
+   * This method reads the length of the array and then extracts the corresponding bytes.
+   * It advances the internal offset by the number of bytes read, including the length prefix.
+   *
+   * @returns A Buffer instance containing the deserialized byte array.
+   */
+  public vector() {
+    return this.exec(deserializeBufferFromVector);
+  }
+
+  /**
+   * Extract a sub-buffer with the specified width, advancing the internal offset.
+   * The function slices the buffer from the current offset to the offset plus the provided width,
+   * and advances the internal offset by the width. This can be useful for working with fixed-width
+   * structures within the original buffer.
+   *
+   * @param width - The number of bytes to include in the extracted sub-buffer.
+   * @returns A sub-buffer containing the specified number of bytes from the original buffer.
+   */
+  public buffer(width: number) {
+    const buf = this.buf.slice(this.offset, this.offset + width);
+    this.offset += width;
+    return buf;
+  }
+
+  /**
+   * Deserialize a string from the internal buffer.
+   * It first deserializes a vector representing the UTF-8 encoded string from the buffer,
+   * and then converts it to a string.
+   *
+   * @returns The deserialized string.
+   */
+  public string() {
+    return this.vector().toString();
+  }
+
+  /**
+   * Deserialize a Date object from the internal buffer.
+   * The date value is expected to be stored as a 64-bit BigInt representing the number of milliseconds since the Unix epoch.
+   * Advances the internal offset by 8 bytes after deserialization.
+   *
+   * @returns A Date instance representing the deserialized date value.
+   */
+  public date() {
+    return new Date(Number(this.bigInt(8)));
+  }
+
+  /**
+   * Deserialize an array of elements using the provided deserialization function.
+   * This method reads the serialized data from the buffer and deserializes each element in the array
+   * using the given 'fn' deserialization function. The returned array contains the deserialized elements
+   * in their original order.
+   *
+   * @param fn - The deserialization function to be applied on each element in the array.
+   * @returns An array containing the deserialized elements.
+   */
+  public deserializeArray<T>(fn: DeserializeFn<T>) {
+    return this.exec((buf: Buffer, offset: number) => deserializeArrayFromVector(fn, buf, offset));
+  }
+
+  /**
+   * Executes the given deserialization function on this Deserializer's buffer and updates the internal offset.
+   * The DeserializeFn<T> should take a Buffer and an offset as input, and return an object containing the deserialized
+   * element and the number of bytes advanced in the buffer. This method is useful for custom deserialization logic
+   * or implementing new deserialization functions.
+   *
+   * @typeparam T - The type of the deserialized element.
+   * @param fn - The deserialization function to execute.
+   * @returns The deserialized element of type T.
+   */
+  public exec<T>(fn: DeserializeFn<T>): T {
+    const { elem, adv } = fn(this.buf, this.offset);
+    this.offset += adv;
+    return elem;
+  }
+
+  /**
+   * Returns the current offset value in the Deserializer instance.
+   * The offset is updated as elements are deserialized from the buffer.
+   * It can be useful for tracking the position in the buffer during complex deserialization processes.
+   *
+   * @returns The current offset value as a number.
+   */
+  public getOffset() {
+    return this.offset;
+  }
+}