json-as 0.9.8 → 0.9.9-a

package/assembly/serialize/unknown.ts

@@ -1,7 +1,6 @@
 import { JSON } from "..";
-import { Sink } from "../src/sink";
-import { __atoi_fast } from "../src/util";
-import { serializeUnknownArray } from "./array/unknown";
+import { Sink } from "../sink";
+import { __atoi_fast } from "../util";
 import { serializeBool } from "./bool";
 import { serializeFloat } from "./float";
 import { serializeInteger } from "./integer";
@@ -13,7 +12,8 @@ import { serializeString } from "./string";
  * @param data - The JSON.Value to be serialized.
  * @returns The serialized result.
  */
-export function serializeUnknown(data: JSON.Value): string {
+// @ts-ignore: Decorator valid here
+@inline export function serializeUnknown(data: JSON.Value): string {
     const type = data.type;
     switch (type) {
         case JSON.Types.String: {
@@ -41,5 +41,5 @@ export function serializeUnknown(data: JSON.Value): string {
             return serializeFloat(data.get<f64>());
         }
     }
-    return serializeUnknownArray(data.get<JSON.Value[]>());
+    return "ERROR"//serializeUnknownArray(data.get<JSON.Value[]>());
 }

package/assembly/test.ts

@@ -1,51 +1,78 @@
-import { JSON } from ".";
+import { JSON } from "json-as/assembly";
 
-// @json or @serializable work here
 @json
-class Vec3 {
-  x: f32 = 0.0;
-  y: f32 = 0.0;
-  z: f32 = 0.0;
-}
+class TokenMetaData {
+    id: u64;
+    name: string;
+    uri: string;
 
-class Box<T> {
-  value: T;
+    constructor(id: u64, name: string, uri: string) {
+        this.id = id;
+        this.name = name;
+        this.uri = uri;
+    }
 }
 
 @json
-class Player {
-  @alias("first name")
-  @omitnull()
-  firstName: string | null;
-  lastName!: string;
-  lastActive!: i32[];
-  // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif("this.age < 18")
-  age!: i32;
-  @omitnull()
-  pos!: Vec3 | null;
-  isVerified!: boolean;
-  @flatten("value")
-  box: Box<i32> | null;
+class NonFungibleToken {
+    owner: string = "";
+    counter: u64 = 0;
+    tokens: Map<u64, TokenMetaData> = new Map<u64, TokenMetaData>();
+    owners: Map<u64, string> = new Map<u64, string>();
+    balances: Map<string, u64[]> = new Map<string, u64[]>();
+
+    constructor() { }
+
+    mint(name: string, uri: string, toAddress: string): u64 {
+        this.counter += 1;
+        const id = this.counter;
+
+        const tokenMetaData = new TokenMetaData(id, name, uri);
+
+        this.tokens.set(id, tokenMetaData);
+        this.owners.set(id, toAddress);
+
+        if (!this.balances.has(toAddress)) {
+            this.balances.set(toAddress, []);
+        }
+
+        this.balances.get(toAddress).push(id);
+
+        return id;
+    }
 }
+function readStringFromMemory(ptr: usize): string {
+    let len: i32 = load<u32>(ptr)
+    let buffer = new Uint8Array(len);
+
+    for (let i = 0; i < len; ++i) {
+        buffer[i] = load<u8>(ptr + 4 + i);
+    }
+
+    let s = String.UTF8.decode(buffer.buffer);
+    return s
+}
+
+function getLengthPrefixedString(s: string): ArrayBuffer {
+    let stringBuf = Uint8Array.wrap(String.UTF8.encode(s))
+    let newLen = stringBuf.byteLength
+    let buffer = new ArrayBuffer(4 + newLen);
+    let dataView = new DataView(buffer);
+
+    dataView.setUint32(0, newLen, true);
+
+    for (let i = 0; i < newLen; ++i) {
+        dataView.setInt8(4 + i, stringBuf[i])
+    }
+
+    return buffer
+}
+
+const s1 = getLengthPrefixedString("hello world");
+console.log(Uint8Array.wrap(s1).join(" "));
+const s2 = readStringFromMemory(changetype<usize>(s1));
+console.log(s2);
 
-const player: Player = {
-  firstName: null,
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: {
-    x: 3.4,
-    y: 1.2,
-    z: 8.3
-  },
-  isVerified: true,
-  box: null
-};
-
-const stringified = JSON.stringify<Player>(player);
-
-const parsed = JSON.parse<Player>(stringified);
-
-console.log("Stringified: " + stringified);
-console.log("Parsed: " + JSON.stringify(parsed));
+let state = JSON.parse<NonFungibleToken>('{"owner":"","counter":1,"tokens":{"1":{"id":1,"name":"foo","uri":"bar"}},"owners":{"1":"baz"},"balances":{"baz":[1]}}');
+state.mint("foo", "bar", "baz")
+console.log(JSON.stringify(state))

package/assembly/types.ts

@@ -0,0 +1,4 @@
+@json
+export class Vec3 {
+  x: f64 = 1.0;
+}

package/assembly/{src/util.ts → util.ts}

@@ -1,6 +1,6 @@
-import { StringSink } from "as-string-sink/assembly";
 import { isSpace } from "util/string";
 import { BACK_SLASH, QUOTE } from "./chars";
+import { Sink } from "./sink";
 
 // @ts-ignore: Decorator
 export function isMap<T>(): bool {
@@ -15,7 +15,7 @@ export function unsafeCharCodeAt(data: string, pos: i32): i32 {
 
 // @ts-ignore: Decorator
 export function removeWhitespace(data: string): string {
-  const result = new StringSink();
+  const result = new Sink();
   let instr = false;
   for (let i = 0; i < data.length; i++) {
     const char = unsafeCharCodeAt(data, i);
@@ -258,7 +258,7 @@ export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u
  */
 
 // @ts-ignore
-@global export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
+export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
   if (!end) end = start + u32(str.length << 1);

package/bench/benchmark.ts

@@ -1,5 +1,5 @@
 import { bench, blackbox } from "as-bench/assembly/bench";
-import { __atoi_fast } from "../assembly/src/util";
+import { __atoi_fast } from "../assembly/util";
 import { JSON } from "../assembly";
 
 @json