feat: add token create event handling (#116)

src/const.ts

@@ -24,6 +24,10 @@ export const eventTypeNameToIndices: {
   [EventType.accountMultisigWithdraw]: [9, [1, 4]],
   [EventType.accountMultisigSetDefaults]: [9, [1, 5]],
   [EventType.accountMultisigExpired]: [9, [1, 6]],
+  [EventType.tokenCreate]: [11, 0],
+  [EventType.tokenUpdate]: [11, 1],
+  [EventType.tokenAddExtInfo]: [11, 2],
+  [EventType.tokenRemoveExtInfo]: [11, 3],
   [EventType.mint]: [12, 0],
   [EventType.burn]: [12, 1],
   [EventType.kvstoreTransfer]: [13, 0],

src/identity/address.ts

@@ -16,7 +16,7 @@ export class Address {
     return new Address()
   }
 
-  static illegal(): Address { 
+  static illegal(): Address {
     return new Address(Buffer.from([0x02]))
   }
 
@@ -62,7 +62,7 @@ export class Address {
     if (this.isAnonymous()) {
       return ANON_IDENTITY
     }
-    if (this.isIllegal()) { 
+    if (this.isIllegal()) {
       return ILLEGAL_IDENTITY
     }
     const identity = this.toBuffer()

src/identity/anonymous/anonymous-identity.ts

@@ -3,7 +3,7 @@ import { EMPTY } from "../../message/cose"
 import { Address } from "../address"
 
 export class AnonymousIdentity extends Identity {
-  static dataType = 'anonymous'
+  static dataType = "anonymous"
 
   async sign() {
     return EMPTY

src/identity/ed25519/ed25519-key-pair-identity.ts

@@ -2,11 +2,11 @@ import forge, { pki } from "node-forge"
 import * as bip39 from "bip39"
 import { CoseKey } from "../../message/cose"
 const ed25519 = pki.ed25519
-import {Identity, PublicKeyIdentity} from "../types"
+import { Identity, PublicKeyIdentity } from "../types"
 import { Address } from "../address"
 
 export class Ed25519KeyPairIdentity extends PublicKeyIdentity {
-  static dataType = 'ed25519'
+  static dataType = "ed25519"
 
   publicKey: ArrayBuffer
   protected privateKey: ArrayBuffer

src/identity/identity.test.ts

@@ -82,7 +82,7 @@ describe("identity", () => {
     expect(bob.withSubresource(2)).toStrictEqual(charlie)
   })
 
-  test("illegal text format", () => {   
+  test("illegal text format", () => {
     const illegal = Address.fromString("maiyg")
     const illegalStr = Address.illegal().toString()
 
@@ -97,5 +97,4 @@ describe("identity", () => {
     expect(illegal.isIllegal()).toBe(true)
     expect(illegal.toHex()).toStrictEqual(illegalHex)
   })
-
 })

src/identity/webauthn/webauthn-identity.ts

@@ -3,15 +3,15 @@ import { ONE_MINUTE } from "../../const"
 import { CoseKey, EMPTY } from "../../message/cose"
 import { makeRandomBytes } from "../../utils"
 import { Address } from "../address"
-import {Identity, PublicKeyIdentity} from "../types"
+import { Identity, PublicKeyIdentity } from "../types"
 const sha512 = require("js-sha512")
 
 export class WebAuthnIdentity extends PublicKeyIdentity {
   publicKey: ArrayBuffer
   rawId: ArrayBuffer
   cosePublicKey: ArrayBuffer
 
-  static dataType = 'webauthn'
+  static dataType = "webauthn"
 
   constructor(cosePublicKey: ArrayBuffer, rawId: ArrayBuffer) {
     super()

src/message/cbor.test.ts

@@ -1,8 +1,8 @@
-import { tag } from "./cbor";
+import { tag } from "./cbor"
 
 describe("cbor", () => {
   test("tag", () => {
-    const tagged = tag(1, "foo");
-    expect(tagged).toMatchObject({ tag: 1, value: "foo", err: undefined });
-  });
-});
+    const tagged = tag(1, "foo")
+    expect(tagged).toMatchObject({ tag: 1, value: "foo", err: undefined })
+  })
+})

src/message/cbor.ts

@@ -1,8 +1,8 @@
-import cbor from "cbor";
+import cbor from "cbor"
 
-export type CborData = Buffer;
-export type CborMap = Map<string | number, any>;
+export type CborData = Buffer
+export type CborMap = Map<string | number, any>
 
 export function tag(tag: number, content: any) {
-  return new cbor.Tagged(tag, content);
+  return new cbor.Tagged(tag, content)
 }

src/message/error.test.ts

@@ -1,4 +1,4 @@
-import * as error from "./error";
+import * as error from "./error"
 
 describe("ManyError", function () {
   it("replaces fields", () => {
@@ -10,11 +10,11 @@ describe("ManyError", function () {
         "1": "ONE",
         "2": "TWO",
       },
-    };
-    const err = new error.ManyError(manyError);
+    }
+    const err = new error.ManyError(manyError)
 
-    expect(err.toString()).toBe("Error: Hello ZERO and TWO.");
-  });
+    expect(err.toString()).toBe("Error: Hello ZERO and TWO.")
+  })
 
   it("works with double brackets", () => {
     const manyError = {
@@ -25,9 +25,9 @@ describe("ManyError", function () {
         "1": "ONE",
         "2": "TWO",
       },
-    };
-    const err = new error.ManyError(manyError);
+    }
+    const err = new error.ManyError(manyError)
 
-    expect(err.toString()).toBe("Error: /{}{ZERO}{}}{TWO.");
-  });
-});
+    expect(err.toString()).toBe("Error: /{}{ZERO}{}}{TWO.")
+  })
+})

src/message/error.ts

@@ -1,39 +1,39 @@
 export interface SerializedManyError {
-  "0"?: number;
-  "1"?: string;
-  "2"?: { [field: string]: string };
+  "0"?: number
+  "1"?: string
+  "2"?: { [field: string]: string }
 }
 
 export class ManyError extends Error {
-  public code: Number;
-  public fields: { [field: string]: string };
+  public code: Number
+  public fields: { [field: string]: string }
 
   constructor(error: SerializedManyError) {
     // Error messages replace `{NAME}` with error["2"].name
-    const { "0": code, "1": message, "2": fields } = error;
+    const { "0": code, "1": message, "2": fields } = error
     if (message === undefined) {
       super(
         `ManyError(${code || 0}) message=${JSON.stringify(
-          message
-        )} fields=${JSON.stringify(fields)}`
-      );
+          message,
+        )} fields=${JSON.stringify(fields)}`,
+      )
     } else {
-      const re = /\{\{|\}\}|\{[^\}\s]*\}/g;
+      const re = /\{\{|\}\}|\{[^\}\s]*\}/g
       super(
-        message.replace(re, (fieldName) => {
+        message.replace(re, fieldName => {
           switch (fieldName) {
             case "{{":
-              return "{";
+              return "{"
             case "}}":
-              return "}";
+              return "}"
             default:
-              return (fields && fields[fieldName.slice(1, -1)]) || "";
+              return (fields && fields[fieldName.slice(1, -1)]) || ""
           }
-        })
-      );
+        }),
+      )
     }
 
-    this.code = code || 0;
-    this.fields = fields || {};
+    this.code = code || 0
+    this.fields = fields || {}
   }
 }

src/message/message.test.ts

@@ -1,17 +1,17 @@
-import { Message } from "../message";
+import { Message } from "../message"
 
 describe("Message", () => {
   test("can be constructed from an object", () => {
-    const msg = { method: "info" };
-    const req = Message.fromObject(msg);
+    const msg = { method: "info" }
+    const req = Message.fromObject(msg)
 
-    expect(req).toHaveProperty("content");
-  });
+    expect(req).toHaveProperty("content")
+  })
   test("can be serialized/deserialized", async () => {
     const msg = { method: "info" }
     const req = Message.fromObject(msg)
     const cbor = await req.toCborData()
 
     expect(Message.fromCborData(cbor)).toStrictEqual(req)
   })
-});
+})

src/network/modules/compute/compute.ts

@@ -1,5 +1,5 @@
-import {Message} from "../../../message"
-import {makeRandomBytes} from "../../../utils"
+import { Message } from "../../../message"
+import { makeRandomBytes } from "../../../utils"
 import {
   ComputeCloseParam,
   ComputeDeployParam,
@@ -34,7 +34,7 @@ export const Compute: ComputeModule = {
     const res = await this.call("compute.list", data)
     return getDeploymentList(res)
   },
- }
+}
 
 function makeComputeDeployData(param: ComputeDeployParam): Map<number, any> {
   const data = new Map()
@@ -56,11 +56,11 @@ function makeComputeCloseData(param: ComputeCloseParam): Map<number, any> {
 }
 
 function makeComputeListData(param: ComputeListParam): Map<number, any> {
-    const data = new Map()
-    if (param.owner) {
-        data.set(0, param.owner)
-    }
-    return data
+  const data = new Map()
+  if (param.owner) {
+    data.set(0, param.owner)
+  }
+  return data
 }
 
 function getComputeInfo(message: Message): ComputeInfo {
@@ -75,19 +75,24 @@ export function getDeploymentList(message: Message): DeploymentList {
   const data = message.getPayload()
   const result: DeploymentList = {
     deployments: data.get(0).map((item: any) => ({
-        status: item.get(0),
-        dseq: item.get(1),
-        image: item.get(3),
-        ...(item.get(2) && { meta: {
-            provider: item.get(2).get(0),
-            price: item.get(2).get(2),
-            provider_info: {
-                ...(item.get(2).get(1).get(0) && { host: item.get(2).get(1).get(0)}),
-                port: item.get(2).get(1).get(1),
-                external_port: item.get(2).get(1).get(2),
-                protocol: item.get(2).get(1).get(3),
-            }
-          }})
-  }))}
+      status: item.get(0),
+      dseq: item.get(1),
+      image: item.get(3),
+      ...(item.get(2) && {
+        meta: {
+          provider: item.get(2).get(0),
+          price: item.get(2).get(2),
+          provider_info: {
+            ...(item.get(2).get(1).get(0) && {
+              host: item.get(2).get(1).get(0),
+            }),
+            port: item.get(2).get(1).get(1),
+            external_port: item.get(2).get(1).get(2),
+            protocol: item.get(2).get(1).get(3),
+          },
+        },
+      }),
+    })),
+  }
   return result
 }

src/network/modules/compute/types.ts

@@ -22,53 +22,53 @@ export enum Region {
 
 export enum ComputeStatus {
   Deployed = 0,
-  Closed = 1
+  Closed = 1,
 }
 
 export enum ServiceProtocol {
-    TCP = 0,
-    UDP = 1,
+  TCP = 0,
+  UDP = 1,
 }
 
 export interface ComputeInfo {
   hash: string
 }
 
 export interface ComputeDeployParam {
-  image: string,
-  port: number,
-  num_cpu: number,
-  num_memory: number,
-  memory_type: ByteUnit,
-  num_storage: number,
-  storage_type: ByteUnit,
-  region: Region,
+  image: string
+  port: number
+  num_cpu: number
+  num_memory: number
+  memory_type: ByteUnit
+  num_storage: number
+  storage_type: ByteUnit
+  region: Region
 }
 
 export interface ComputeCloseParam {
   dseq: number
 }
 
 export interface ComputeListParam {
-  owner? : string | null,
+  owner?: string | null
 }
 
 export interface ProviderInfo {
-  host?: string,
-  port: number,
-  external_port: number,
-  protocol: ServiceProtocol,
+  host?: string
+  port: number
+  external_port: number
+  protocol: ServiceProtocol
 }
 
 export interface DeploymentInfo {
-  provider: string,
-  provider_info: ProviderInfo,
+  provider: string
+  provider_info: ProviderInfo
 }
 
 export interface DeploymentMeta {
-  status: ComputeStatus,
-  dseq: number,
-  meta?: DeploymentInfo,
+  status: ComputeStatus
+  dseq: number
+  meta?: DeploymentInfo
 }
 
 export interface DeploymentList {
@@ -77,15 +77,7 @@ export interface DeploymentList {
 
 export interface ComputeModule extends NetworkModule {
   info: () => Promise<ComputeInfo>
-  deploy: (
-    data: ComputeDeployParam,
-    opts?: { nonce?: ArrayBuffer },
-  ) => void
-  close: (
-    data: ComputeCloseParam,
-    opts?: { nonce?: ArrayBuffer },
-  ) => void
-  list: (
-    data: ComputeListParam,
-  ) => Promise<DeploymentList>
+  deploy: (data: ComputeDeployParam, opts?: { nonce?: ArrayBuffer }) => void
+  close: (data: ComputeCloseParam, opts?: { nonce?: ArrayBuffer }) => void
+  list: (data: ComputeListParam) => Promise<DeploymentList>
 }