@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/utils/abi/coders/abstract-coder.ts

@@ -0,0 +1,239 @@
+"use strict";
+
+import { arrayify, BytesLike, concat, hexConcat, hexlify } from "../bytes";
+import { BigNumber, BigNumberish } from "../bignumber";
+import { defineReadOnly } from "../properties";
+
+import { Logger } from "../../logger";
+const version = "abstract-coder/5.7.0";
+const logger = new Logger(version);
+
+export interface Result extends ReadonlyArray<any> {
+  readonly [key: string]: any;
+}
+
+export function checkResultErrors(
+  result: Result,
+): Array<{ path: Array<string | number>; error: Error }> {
+  // Find the first error (if any)
+  const errors: Array<{ path: Array<string | number>; error: Error }> = [];
+
+  const checkErrors = function (
+    path: Array<string | number>,
+    object: any,
+  ): void {
+    if (!Array.isArray(object)) {
+      return;
+    }
+    for (let key in object) {
+      const childPath = path.slice();
+      childPath.push(key);
+
+      try {
+        checkErrors(childPath, object[key]);
+      } catch (error) {
+        errors.push({ path: childPath, error: error });
+      }
+    }
+  };
+  checkErrors([], result);
+
+  return errors;
+}
+
+export type CoerceFunc = (type: string, value: any) => any;
+
+export abstract class Coder {
+  // The coder name:
+  //   - address, uint256, tuple, array, etc.
+  readonly name: string;
+
+  // The fully expanded type, including composite types:
+  //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.
+  readonly type: string;
+
+  // The localName bound in the signature, in this example it is "baz":
+  //   - tuple(address foo, uint bar) baz
+  readonly localName: string;
+
+  // Whether this type is dynamic:
+  //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.
+  //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)
+  readonly dynamic: boolean;
+
+  constructor(name: string, type: string, localName: string, dynamic: boolean) {
+    // @TODO: defineReadOnly these
+    this.name = name;
+    this.type = type;
+    this.localName = localName;
+    this.dynamic = dynamic;
+  }
+
+  _throwError(message: string, value: any): void {
+    logger.throwArgumentError(message, this.localName, value);
+  }
+
+  abstract encode(writer: Writer, value: any): number;
+  abstract decode(reader: Reader): any;
+
+  abstract defaultValue(): any;
+}
+
+export class Writer {
+  readonly wordSize: number;
+
+  _data: Array<Uint8Array>;
+  _dataLength: number;
+  _padding: Uint8Array;
+
+  constructor(wordSize?: number) {
+    defineReadOnly(this, "wordSize", wordSize || 32);
+    this._data = [];
+    this._dataLength = 0;
+    this._padding = new Uint8Array(wordSize);
+  }
+
+  get data(): string {
+    return hexConcat(this._data);
+  }
+  get length(): number {
+    return this._dataLength;
+  }
+
+  _writeData(data: Uint8Array): number {
+    this._data.push(data);
+    this._dataLength += data.length;
+    return data.length;
+  }
+
+  appendWriter(writer: Writer): number {
+    return this._writeData(concat(writer._data));
+  }
+
+  // Arrayish items; padded on the right to wordSize
+  writeBytes(value: BytesLike): number {
+    let bytes = arrayify(value);
+    const paddingOffset = bytes.length % this.wordSize;
+    if (paddingOffset) {
+      bytes = concat([bytes, this._padding.slice(paddingOffset)]);
+    }
+    return this._writeData(bytes);
+  }
+
+  _getValue(value: BigNumberish): Uint8Array {
+    let bytes = arrayify(BigNumber.from(value));
+    if (bytes.length > this.wordSize) {
+      logger.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
+        length: this.wordSize,
+        offset: bytes.length,
+      });
+    }
+    if (bytes.length % this.wordSize) {
+      bytes = concat([
+        this._padding.slice(bytes.length % this.wordSize),
+        bytes,
+      ]);
+    }
+    return bytes;
+  }
+
+  // BigNumberish items; padded on the left to wordSize
+  writeValue(value: BigNumberish): number {
+    return this._writeData(this._getValue(value));
+  }
+
+  writeUpdatableValue(): (value: BigNumberish) => void {
+    const offset = this._data.length;
+    this._data.push(this._padding);
+    this._dataLength += this.wordSize;
+    return (value: BigNumberish) => {
+      this._data[offset] = this._getValue(value);
+    };
+  }
+}
+
+export class Reader {
+  readonly wordSize: number;
+  readonly allowLoose: boolean;
+
+  readonly _data: Uint8Array;
+  readonly _coerceFunc: CoerceFunc;
+
+  _offset: number;
+
+  constructor(
+    data: BytesLike,
+    wordSize?: number,
+    coerceFunc?: CoerceFunc,
+    allowLoose?: boolean,
+  ) {
+    defineReadOnly(this, "_data", arrayify(data));
+    defineReadOnly(this, "wordSize", wordSize || 32);
+    defineReadOnly(this, "_coerceFunc", coerceFunc);
+    defineReadOnly(this, "allowLoose", allowLoose);
+
+    this._offset = 0;
+  }
+
+  get data(): string {
+    return hexlify(this._data);
+  }
+  get consumed(): number {
+    return this._offset;
+  }
+
+  // The default Coerce function
+  static coerce(name: string, value: any): any {
+    let match = name.match("^u?int([0-9]+)$");
+    if (match && parseInt(match[1]) <= 48) {
+      value = value.toNumber();
+    }
+    return value;
+  }
+
+  coerce(name: string, value: any): any {
+    if (this._coerceFunc) {
+      return this._coerceFunc(name, value);
+    }
+    return Reader.coerce(name, value);
+  }
+
+  _peekBytes(offset: number, length: number, loose?: boolean): Uint8Array {
+    let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;
+    if (this._offset + alignedLength > this._data.length) {
+      if (
+        this.allowLoose &&
+        loose &&
+        this._offset + length <= this._data.length
+      ) {
+        alignedLength = length;
+      } else {
+        logger.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
+          length: this._data.length,
+          offset: this._offset + alignedLength,
+        });
+      }
+    }
+    return this._data.slice(this._offset, this._offset + alignedLength);
+  }
+
+  subReader(offset: number): Reader {
+    return new Reader(
+      this._data.slice(this._offset + offset),
+      this.wordSize,
+      this._coerceFunc,
+      this.allowLoose,
+    );
+  }
+
+  readBytes(length: number, loose?: boolean): Uint8Array {
+    let bytes = this._peekBytes(0, length, !!loose);
+    this._offset += bytes.length;
+    // @TODO: Make sure the length..end bytes are all 0?
+    return bytes.slice(0, length);
+  }
+
+  readValue(): BigNumber {
+    return BigNumber.from(this.readBytes(this.wordSize));
+  }
+}

package/src/bop-sdk/utils/abi/coders/address.ts

@@ -0,0 +1,58 @@
+"use strict";
+
+import { Logger } from "../../logger";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+import bs58 from "@bifproject/bs58";
+import { Buffer } from "buffer";
+
+const version = "address/5.7.0";
+const logger = new Logger(version);
+
+export class AddressCoder extends Coder {
+  constructor(localName: string) {
+    super("address", "address", localName, false);
+  }
+
+  defaultValue(): string {
+    return "0x0000000000000000000000000000000000000000";
+  }
+
+  encode(writer: Writer, value: string): number {
+    let newValue: string = "";
+    try {
+      const bytes = bs58.decode(value.substring(10));
+      const signType = value.substring(8, 9);
+      const encodeType = value.substring(9, 10);
+      const signMap: { [key: string]: string } = { z: "7a" };
+      const encodeMap: { [key: string]: string } = { s: "73", t: "74" };
+      const hex = Buffer.from(bytes).toString("hex");
+      newValue = `0x${signMap[signType] || "65"}${encodeMap[encodeType] || "66"}${hex}`;
+    } catch (error) {
+      this._throwError(error.message, value);
+    }
+    logger.debug(
+      `AddressCoder encode address value:${value}, newValue:${newValue}`,
+    );
+    return writer.writeValue(newValue);
+  }
+
+  decode(reader: Reader): string {
+    const value = reader.readValue().toHexString();
+    const hex = value.substring(6);
+    const bytes = Uint8Array.from(Buffer.from(hex, "hex"));
+    const address = bs58.encode(bytes);
+    const signType = value.substring(2, 4);
+    const encodeType = value.substring(4, 6);
+
+    const signMap: { [key: string]: string } = { "7a": "z" };
+    const encodeMap: { [key: string]: string } = { "73": "s", "74": "t" };
+
+    const newValue = `did:bid:${signMap[signType] || "e"}${encodeMap[encodeType] || "f"}${address}`;
+    logger.debug(
+      `AddressCoder decode address value:${value}, newValue:${newValue}`,
+    );
+    return newValue;
+  }
+}

package/src/bop-sdk/utils/abi/coders/anonymous.ts

@@ -0,0 +1,25 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+// Clones the functionality of an existing Coder, but without a localName
+export class AnonymousCoder extends Coder {
+  private coder: Coder;
+
+  constructor(coder: Coder) {
+    super(coder.name, coder.type, undefined, coder.dynamic);
+    this.coder = coder;
+  }
+
+  defaultValue(): any {
+    return this.coder.defaultValue();
+  }
+
+  encode(writer: Writer, value: any): number {
+    return this.coder.encode(writer, value);
+  }
+
+  decode(reader: Reader): any {
+    return this.coder.decode(reader);
+  }
+}

package/src/bop-sdk/utils/abi/coders/array.ts

@@ -0,0 +1,275 @@
+"use strict";
+
+import { Logger } from "../../logger";
+const version = "array/5.7.0";
+const logger = new Logger(version);
+
+import { Coder, Reader, Result, Writer } from "./abstract-coder";
+import { AnonymousCoder } from "./anonymous";
+
+export function pack(
+  writer: Writer,
+  coders: ReadonlyArray<Coder>,
+  values: Array<any> | { [name: string]: any },
+): number {
+  let arrayValues: Array<any> = null;
+
+  if (Array.isArray(values)) {
+    arrayValues = values;
+  } else if (values && typeof values === "object") {
+    let unique: { [name: string]: boolean } = {};
+
+    arrayValues = coders.map((coder) => {
+      const name = coder.localName;
+      if (!name) {
+        logger.throwError(
+          "cannot encode object for signature with missing names",
+          Logger.errors.INVALID_ARGUMENT,
+          {
+            argument: "values",
+            coder: coder,
+            value: values,
+          },
+        );
+      }
+
+      if (unique[name]) {
+        logger.throwError(
+          "cannot encode object for signature with duplicate names",
+          Logger.errors.INVALID_ARGUMENT,
+          {
+            argument: "values",
+            coder: coder,
+            value: values,
+          },
+        );
+      }
+
+      unique[name] = true;
+
+      return values[name];
+    });
+  } else {
+    logger.throwArgumentError("invalid tuple value", "tuple", values);
+  }
+
+  if (coders.length !== arrayValues.length) {
+    logger.throwArgumentError("types/value length mismatch", "tuple", values);
+  }
+
+  let staticWriter = new Writer(writer.wordSize);
+  let dynamicWriter = new Writer(writer.wordSize);
+
+  let updateFuncs: Array<(baseOffset: number) => void> = [];
+  coders.forEach((coder, index) => {
+    let value = arrayValues[index];
+
+    if (coder.dynamic) {
+      // Get current dynamic offset (for the future pointer)
+      let dynamicOffset = dynamicWriter.length;
+
+      // Encode the dynamic value into the dynamicWriter
+      coder.encode(dynamicWriter, value);
+
+      // Prepare to populate the correct offset once we are done
+      let updateFunc = staticWriter.writeUpdatableValue();
+      updateFuncs.push((baseOffset: number) => {
+        updateFunc(baseOffset + dynamicOffset);
+      });
+    } else {
+      coder.encode(staticWriter, value);
+    }
+  });
+
+  // Backfill all the dynamic offsets, now that we know the static length
+  updateFuncs.forEach((func) => {
+    func(staticWriter.length);
+  });
+
+  let length = writer.appendWriter(staticWriter);
+  length += writer.appendWriter(dynamicWriter);
+  return length;
+}
+
+export function unpack(reader: Reader, coders: Array<Coder>): Result {
+  let values: any = [];
+
+  // A reader anchored to this base
+  let baseReader = reader.subReader(0);
+
+  coders.forEach((coder) => {
+    let value: any = null;
+
+    if (coder.dynamic) {
+      let offset = reader.readValue();
+      let offsetReader = baseReader.subReader(offset.toNumber());
+      try {
+        value = coder.decode(offsetReader);
+      } catch (error) {
+        // Cannot recover from this
+        if (error.code === Logger.errors.BUFFER_OVERRUN) {
+          throw error;
+        }
+        value = error;
+        value.baseType = coder.name;
+        value.name = coder.localName;
+        value.type = coder.type;
+      }
+    } else {
+      try {
+        value = coder.decode(reader);
+      } catch (error) {
+        // Cannot recover from this
+        if (error.code === Logger.errors.BUFFER_OVERRUN) {
+          throw error;
+        }
+        value = error;
+        value.baseType = coder.name;
+        value.name = coder.localName;
+        value.type = coder.type;
+      }
+    }
+
+    if (value != undefined) {
+      values.push(value);
+    }
+  });
+
+  // We only output named properties for uniquely named coders
+  const uniqueNames = coders.reduce(
+    (accum, coder) => {
+      const name = coder.localName;
+      if (name) {
+        if (!accum[name]) {
+          accum[name] = 0;
+        }
+        accum[name]++;
+      }
+      return accum;
+    },
+    <{ [name: string]: number }>{},
+  );
+
+  // Add any named parameters (i.e. tuples)
+  coders.forEach((coder: Coder, index: number) => {
+    let name = coder.localName;
+    if (!name || uniqueNames[name] !== 1) {
+      return;
+    }
+
+    if (name === "length") {
+      name = "_length";
+    }
+
+    if (values[name] != null) {
+      return;
+    }
+
+    const value = values[index];
+
+    if (value instanceof Error) {
+      Object.defineProperty(values, name, {
+        enumerable: true,
+        get: () => {
+          throw value;
+        },
+      });
+    } else {
+      values[name] = value;
+    }
+  });
+
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (value instanceof Error) {
+      Object.defineProperty(values, i, {
+        enumerable: true,
+        get: () => {
+          throw value;
+        },
+      });
+    }
+  }
+
+  return Object.freeze(values);
+}
+
+export class ArrayCoder extends Coder {
+  readonly coder: Coder;
+  readonly length: number;
+
+  constructor(coder: Coder, length: number, localName: string) {
+    const type = coder.type + "[" + (length >= 0 ? length : "") + "]";
+    const dynamic = length === -1 || coder.dynamic;
+    super("array", type, localName, dynamic);
+
+    this.coder = coder;
+    this.length = length;
+  }
+
+  defaultValue(): Array<any> {
+    // Verifies the child coder is valid (even if the array is dynamic or 0-length)
+    const defaultChild = this.coder.defaultValue();
+
+    const result: Array<any> = [];
+    for (let i = 0; i < this.length; i++) {
+      result.push(defaultChild);
+    }
+    return result;
+  }
+
+  encode(writer: Writer, value: Array<any>): number {
+    if (!Array.isArray(value)) {
+      this._throwError("expected array value", value);
+    }
+
+    let count = this.length;
+
+    if (count === -1) {
+      count = value.length;
+      writer.writeValue(value.length);
+    }
+
+    logger.checkArgumentCount(
+      value.length,
+      count,
+      "coder array" + (this.localName ? " " + this.localName : ""),
+    );
+
+    let coders = [];
+    for (let i = 0; i < value.length; i++) {
+      coders.push(this.coder);
+    }
+
+    return pack(writer, coders, value);
+  }
+
+  decode(reader: Reader): any {
+    let count = this.length;
+    if (count === -1) {
+      count = reader.readValue().toNumber();
+
+      // Check that there is *roughly* enough data to ensure
+      // stray random data is not being read as a length. Each
+      // slot requires at least 32 bytes for their value (or 32
+      // bytes as a link to the data). This could use a much
+      // tighter bound, but we are erroring on the side of safety.
+      if (count * 32 > reader._data.length) {
+        logger.throwError(
+          "insufficient data length",
+          Logger.errors.BUFFER_OVERRUN,
+          {
+            length: reader._data.length,
+            count: count,
+          },
+        );
+      }
+    }
+    let coders = [];
+    for (let i = 0; i < count; i++) {
+      coders.push(new AnonymousCoder(this.coder));
+    }
+
+    return reader.coerce(this.name, unpack(reader, coders));
+  }
+}

package/src/bop-sdk/utils/abi/coders/boolean.ts

@@ -0,0 +1,21 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class BooleanCoder extends Coder {
+  constructor(localName: string) {
+    super("bool", "bool", localName, false);
+  }
+
+  defaultValue(): boolean {
+    return false;
+  }
+
+  encode(writer: Writer, value: boolean): number {
+    return writer.writeValue(value ? 1 : 0);
+  }
+
+  decode(reader: Reader): any {
+    return reader.coerce(this.type, !reader.readValue().isZero());
+  }
+}

package/src/bop-sdk/utils/abi/coders/bytes.ts

@@ -0,0 +1,36 @@
+"use strict";
+
+import { arrayify, hexlify } from "../bytes";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class DynamicBytesCoder extends Coder {
+  constructor(type: string, localName: string) {
+    super(type, type, localName, true);
+  }
+
+  defaultValue(): string {
+    return "0x";
+  }
+
+  encode(writer: Writer, value: any): number {
+    value = arrayify(value);
+    let length = writer.writeValue(value.length);
+    length += writer.writeBytes(value);
+    return length;
+  }
+
+  decode(reader: Reader): any {
+    return reader.readBytes(reader.readValue().toNumber(), true);
+  }
+}
+
+export class BytesCoder extends DynamicBytesCoder {
+  constructor(localName: string) {
+    super("bytes", localName);
+  }
+
+  decode(reader: Reader): any {
+    return reader.coerce(this.name, hexlify(super.decode(reader)));
+  }
+}

package/src/bop-sdk/utils/abi/coders/fixed-bytes.ts

@@ -0,0 +1,35 @@
+"use strict";
+
+import { arrayify, BytesLike, hexlify } from "../bytes";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+// @TODO: Merge this with bytes
+export class FixedBytesCoder extends Coder {
+  readonly size: number;
+
+  constructor(size: number, localName: string) {
+    let name = "bytes" + String(size);
+    super(name, name, localName, false);
+    this.size = size;
+  }
+
+  defaultValue(): string {
+    return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(
+      0,
+      2 + this.size * 2,
+    );
+  }
+
+  encode(writer: Writer, value: BytesLike): number {
+    let data = arrayify(value);
+    if (data.length !== this.size) {
+      this._throwError("incorrect data length", value);
+    }
+    return writer.writeBytes(data);
+  }
+
+  decode(reader: Reader): any {
+    return reader.coerce(this.name, hexlify(reader.readBytes(this.size)));
+  }
+}