@caict/bop-typescript-sdk 1.0.0

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

@@ -0,0 +1,25 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class NullCoder extends Coder {
+  constructor(localName: string) {
+    super("null", "", localName, false);
+  }
+
+  defaultValue(): null {
+    return null;
+  }
+
+  encode(writer: Writer, value: any): number {
+    if (value != null) {
+      this._throwError("not null", value);
+    }
+    return writer.writeBytes([]);
+  }
+
+  decode(reader: Reader): any {
+    reader.readBytes(0);
+    return reader.coerce(this.name, null);
+  }
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+import { BigNumber, BigNumberish } from "../bignumber";
+import { MaxUint256, NegativeOne, One, Zero } from "../constants";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class NumberCoder extends Coder {
+  readonly size: number;
+  readonly signed: boolean;
+
+  constructor(size: number, signed: boolean, localName: string) {
+    const name = (signed ? "int" : "uint") + size * 8;
+    super(name, name, localName, false);
+
+    this.size = size;
+    this.signed = signed;
+  }
+
+  defaultValue(): number {
+    return 0;
+  }
+
+  encode(writer: Writer, value: BigNumberish): number {
+    let v = BigNumber.from(value);
+
+    // Check bounds are safe for encoding
+    let maxUintValue = MaxUint256.mask(writer.wordSize * 8);
+    if (this.signed) {
+      let bounds = maxUintValue.mask(this.size * 8 - 1);
+      if (v.gt(bounds) || v.lt(bounds.add(One).mul(NegativeOne))) {
+        this._throwError("value out-of-bounds", value);
+      }
+    } else if (v.lt(Zero) || v.gt(maxUintValue.mask(this.size * 8))) {
+      this._throwError("value out-of-bounds", value);
+    }
+
+    v = v.toTwos(this.size * 8).mask(this.size * 8);
+
+    if (this.signed) {
+      v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);
+    }
+
+    return writer.writeValue(v);
+  }
+
+  decode(reader: Reader): any {
+    let value = reader.readValue().mask(this.size * 8);
+
+    if (this.signed) {
+      value = value.fromTwos(this.size * 8);
+    }
+
+    return reader.coerce(this.name, value);
+  }
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+import { toUtf8Bytes, toUtf8String } from "../strings";
+
+import { Reader, Writer } from "./abstract-coder";
+import { DynamicBytesCoder } from "./bytes";
+
+export class StringCoder extends DynamicBytesCoder {
+  constructor(localName: string) {
+    super("string", localName);
+  }
+
+  defaultValue(): string {
+    return "";
+  }
+
+  encode(writer: Writer, value: any): number {
+    return super.encode(writer, toUtf8Bytes(value));
+  }
+
+  decode(reader: Reader): any {
+    return toUtf8String(super.decode(reader));
+  }
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+import { pack, unpack } from "./array";
+
+export class TupleCoder extends Coder {
+  readonly coders: Array<Coder>;
+
+  constructor(coders: Array<Coder>, localName: string) {
+    let dynamic = false;
+    const types: Array<string> = [];
+    coders.forEach((coder) => {
+      if (coder.dynamic) {
+        dynamic = true;
+      }
+      types.push(coder.type);
+    });
+    const type = "tuple(" + types.join(",") + ")";
+
+    super("tuple", type, localName, dynamic);
+    this.coders = coders;
+  }
+
+  defaultValue(): any {
+    const values: any = [];
+    this.coders.forEach((coder) => {
+      values.push(coder.defaultValue());
+    });
+
+    // We only output named properties for uniquely named coders
+    const uniqueNames = this.coders.reduce(
+      (accum, coder) => {
+        const name = coder.localName;
+        if (name) {
+          if (!accum[name]) {
+            accum[name] = 0;
+          }
+          accum[name]++;
+        }
+        return accum;
+      },
+      <{ [name: string]: number }>{},
+    );
+
+    // Add named values
+    this.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;
+      }
+
+      values[name] = values[index];
+    });
+
+    return Object.freeze(values);
+  }
+
+  encode(writer: Writer, value: Array<any> | { [name: string]: any }): number {
+    return pack(writer, this.coders, value);
+  }
+
+  decode(reader: Reader): any {
+    return reader.coerce(this.name, unpack(reader, this.coders));
+  }
+}

package/src/bop-sdk/utils/abi/constants/addresses.ts

@@ -0,0 +1 @@
+export const AddressZero = "0x0000000000000000000000000000000000000000";

package/src/bop-sdk/utils/abi/constants/bignumbers.ts

@@ -0,0 +1,30 @@
+import { BigNumber } from "../bignumber";
+
+const NegativeOne: BigNumber = /*#__PURE__*/ BigNumber.from(-1);
+const Zero: BigNumber = /*#__PURE__*/ BigNumber.from(0);
+const One: BigNumber = /*#__PURE__*/ BigNumber.from(1);
+const Two: BigNumber = /*#__PURE__*/ BigNumber.from(2);
+const WeiPerEther: BigNumber = /*#__PURE__*/ BigNumber.from(
+  "1000000000000000000",
+);
+const MaxUint256: BigNumber = /*#__PURE__*/ BigNumber.from(
+  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+);
+
+const MinInt256: BigNumber = /*#__PURE__*/ BigNumber.from(
+  "-0x8000000000000000000000000000000000000000000000000000000000000000",
+);
+const MaxInt256: BigNumber = /*#__PURE__*/ BigNumber.from(
+  "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+);
+
+export {
+  NegativeOne,
+  Zero,
+  One,
+  Two,
+  WeiPerEther,
+  MaxUint256,
+  MinInt256,
+  MaxInt256,
+};

package/src/bop-sdk/utils/abi/constants/hashes.ts

@@ -0,0 +1,2 @@
+export const HashZero =
+  "0x0000000000000000000000000000000000000000000000000000000000000000";

package/src/bop-sdk/utils/abi/constants/index.ts

@@ -0,0 +1,15 @@
+"use strict";
+
+export { AddressZero } from "./addresses";
+export {
+  NegativeOne,
+  Zero,
+  One,
+  Two,
+  WeiPerEther,
+  MaxUint256,
+  MinInt256,
+  MaxInt256,
+} from "./bignumbers";
+export { HashZero } from "./hashes";
+export { EtherSymbol } from "./strings";

package/src/bop-sdk/utils/abi/constants/strings.ts

@@ -0,0 +1,2 @@
+// NFKC (composed)             // (decomposed)
+export const EtherSymbol = "\u039e"; // "\uD835\uDF63";