diff --git a/assembly/koinos/koindx_tracker/koindx_tracker.ts b/assembly/koinos/koindx_tracker/koindx_tracker.ts
new file mode 100644
index 0000000..2ec622b
--- /dev/null
+++ b/assembly/koinos/koindx_tracker/koindx_tracker.ts
@@ -0,0 +1,217 @@
+import { Writer, Reader } from "as-proto";
+
+export namespace koindx_tracker {
+  export class liquidity_record {
+    static encode(message: liquidity_record, writer: Writer): void {
+      if (message.address.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.address);
+      }
+
+      if (message.balance != 0) {
+        writer.uint32(16);
+        writer.uint64(message.balance);
+      }
+
+      if (message.prev_coin_ms_hi != 0) {
+        writer.uint32(24);
+        writer.uint64(message.prev_coin_ms_hi);
+      }
+
+      if (message.prev_coin_ms_lo != 0) {
+        writer.uint32(32);
+        writer.uint64(message.prev_coin_ms_lo);
+      }
+
+      if (message.last_update != 0) {
+        writer.uint32(40);
+        writer.uint64(message.last_update);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): liquidity_record {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new liquidity_record();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.address = reader.bytes();
+            break;
+
+          case 2:
+            message.balance = reader.uint64();
+            break;
+
+          case 3:
+            message.prev_coin_ms_hi = reader.uint64();
+            break;
+
+          case 4:
+            message.prev_coin_ms_lo = reader.uint64();
+            break;
+
+          case 5:
+            message.last_update = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    address: Uint8Array;
+    balance: u64;
+    prev_coin_ms_hi: u64;
+    prev_coin_ms_lo: u64;
+    last_update: u64;
+
+    constructor(
+      address: Uint8Array = new Uint8Array(0),
+      balance: u64 = 0,
+      prev_coin_ms_hi: u64 = 0,
+      prev_coin_ms_lo: u64 = 0,
+      last_update: u64 = 0
+    ) {
+      this.address = address;
+      this.balance = balance;
+      this.prev_coin_ms_hi = prev_coin_ms_hi;
+      this.prev_coin_ms_lo = prev_coin_ms_lo;
+      this.last_update = last_update;
+    }
+  }
+
+  @unmanaged
+  export class tvl_record {
+    static encode(message: tvl_record, writer: Writer): void {
+      if (message.value != 0) {
+        writer.uint32(8);
+        writer.uint64(message.value);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): tvl_record {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new tvl_record();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.value = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    value: u64;
+
+    constructor(value: u64 = 0) {
+      this.value = value;
+    }
+  }
+
+  export class initialize_event {
+    static encode(message: initialize_event, writer: Writer): void {
+      if (message.token_a.length != 0) {
+        writer.uint32(10);
+        writer.string(message.token_a);
+      }
+
+      if (message.token_b.length != 0) {
+        writer.uint32(18);
+        writer.string(message.token_b);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): initialize_event {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new initialize_event();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.token_a = reader.string();
+            break;
+
+          case 2:
+            message.token_b = reader.string();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    token_a: string;
+    token_b: string;
+
+    constructor(token_a: string = "", token_b: string = "") {
+      this.token_a = token_a;
+      this.token_b = token_b;
+    }
+  }
+
+  @unmanaged
+  export class sync_event {
+    static encode(message: sync_event, writer: Writer): void {
+      if (message.reserve_a != 0) {
+        writer.uint32(8);
+        writer.uint64(message.reserve_a);
+      }
+
+      if (message.reserve_b != 0) {
+        writer.uint32(16);
+        writer.uint64(message.reserve_b);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): sync_event {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new sync_event();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.reserve_a = reader.uint64();
+            break;
+
+          case 2:
+            message.reserve_b = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    reserve_a: u64;
+    reserve_b: u64;
+
+    constructor(reserve_a: u64 = 0, reserve_b: u64 = 0) {
+      this.reserve_a = reserve_a;
+      this.reserve_b = reserve_b;
+    }
+  }
+}
diff --git a/assembly/koinos/rpc/koindx_tracker/koindx_tracker_rpc.ts b/assembly/koinos/rpc/koindx_tracker/koindx_tracker_rpc.ts
new file mode 100644
index 0000000..7d29544
--- /dev/null
+++ b/assembly/koinos/rpc/koindx_tracker/koindx_tracker_rpc.ts
@@ -0,0 +1,716 @@
+import { Writer, Reader } from "as-proto";
+import { rpc } from "../rpc";
+
+export namespace koindx_tracker_rpc {
+  export class pool_pair {
+    static encode(message: pool_pair, writer: Writer): void {
+      if (message.pool.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.pool);
+      }
+
+      if (message.token_a.length != 0) {
+        writer.uint32(18);
+        writer.string(message.token_a);
+      }
+
+      if (message.token_b.length != 0) {
+        writer.uint32(26);
+        writer.string(message.token_b);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): pool_pair {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new pool_pair();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.pool = reader.bytes();
+            break;
+
+          case 2:
+            message.token_a = reader.string();
+            break;
+
+          case 3:
+            message.token_b = reader.string();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    pool: Uint8Array;
+    token_a: string;
+    token_b: string;
+
+    constructor(
+      pool: Uint8Array = new Uint8Array(0),
+      token_a: string = "",
+      token_b: string = ""
+    ) {
+      this.pool = pool;
+      this.token_a = token_a;
+      this.token_b = token_b;
+    }
+  }
+
+  export class get_pools_request {
+    static encode(message: get_pools_request, writer: Writer): void {
+      if (message.start.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.start);
+      }
+
+      if (message.pool.length != 0) {
+        writer.uint32(18);
+        writer.bytes(message.pool);
+      }
+
+      if (message.limit != 0) {
+        writer.uint32(24);
+        writer.uint64(message.limit);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_pools_request {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_pools_request();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.start = reader.bytes();
+            break;
+
+          case 2:
+            message.pool = reader.bytes();
+            break;
+
+          case 3:
+            message.limit = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    start: Uint8Array;
+    pool: Uint8Array;
+    limit: u64;
+
+    constructor(
+      start: Uint8Array = new Uint8Array(0),
+      pool: Uint8Array = new Uint8Array(0),
+      limit: u64 = 0
+    ) {
+      this.start = start;
+      this.pool = pool;
+      this.limit = limit;
+    }
+  }
+
+  export class get_pools_response {
+    static encode(message: get_pools_response, writer: Writer): void {
+      const unique_name_values = message.values;
+      for (let i = 0; i < unique_name_values.length; ++i) {
+        writer.uint32(10);
+        writer.fork();
+        pool_pair.encode(unique_name_values[i], writer);
+        writer.ldelim();
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_pools_response {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_pools_response();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.values.push(pool_pair.decode(reader, reader.uint32()));
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    values: Array<pool_pair>;
+
+    constructor(values: Array<pool_pair> = []) {
+      this.values = values;
+    }
+  }
+
+  export class account_liquidity {
+    static encode(message: account_liquidity, writer: Writer): void {
+      if (message.address.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.address);
+      }
+
+      if (message.balance != 0) {
+        writer.uint32(16);
+        writer.uint64(message.balance);
+      }
+
+      if (message.coin_ms_hi != 0) {
+        writer.uint32(24);
+        writer.uint64(message.coin_ms_hi);
+      }
+
+      if (message.coin_ms_lo != 0) {
+        writer.uint32(32);
+        writer.uint64(message.coin_ms_lo);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): account_liquidity {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new account_liquidity();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.address = reader.bytes();
+            break;
+
+          case 2:
+            message.balance = reader.uint64();
+            break;
+
+          case 3:
+            message.coin_ms_hi = reader.uint64();
+            break;
+
+          case 4:
+            message.coin_ms_lo = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    address: Uint8Array;
+    balance: u64;
+    coin_ms_hi: u64;
+    coin_ms_lo: u64;
+
+    constructor(
+      address: Uint8Array = new Uint8Array(0),
+      balance: u64 = 0,
+      coin_ms_hi: u64 = 0,
+      coin_ms_lo: u64 = 0
+    ) {
+      this.address = address;
+      this.balance = balance;
+      this.coin_ms_hi = coin_ms_hi;
+      this.coin_ms_lo = coin_ms_lo;
+    }
+  }
+
+  export class get_liquidity_request {
+    static encode(message: get_liquidity_request, writer: Writer): void {
+      if (message.pool.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.pool);
+      }
+
+      if (message.start.length != 0) {
+        writer.uint32(18);
+        writer.bytes(message.start);
+      }
+
+      if (message.limit != 0) {
+        writer.uint32(24);
+        writer.uint64(message.limit);
+      }
+
+      if (message.start_ms != 0) {
+        writer.uint32(32);
+        writer.uint64(message.start_ms);
+      }
+
+      if (message.end_ms != 0) {
+        writer.uint32(40);
+        writer.uint64(message.end_ms);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_liquidity_request {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_liquidity_request();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.pool = reader.bytes();
+            break;
+
+          case 2:
+            message.start = reader.bytes();
+            break;
+
+          case 3:
+            message.limit = reader.uint64();
+            break;
+
+          case 4:
+            message.start_ms = reader.uint64();
+            break;
+
+          case 5:
+            message.end_ms = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    pool: Uint8Array;
+    start: Uint8Array;
+    limit: u64;
+    start_ms: u64;
+    end_ms: u64;
+
+    constructor(
+      pool: Uint8Array = new Uint8Array(0),
+      start: Uint8Array = new Uint8Array(0),
+      limit: u64 = 0,
+      start_ms: u64 = 0,
+      end_ms: u64 = 0
+    ) {
+      this.pool = pool;
+      this.start = start;
+      this.limit = limit;
+      this.start_ms = start_ms;
+      this.end_ms = end_ms;
+    }
+  }
+
+  export class get_liquidity_response {
+    static encode(message: get_liquidity_response, writer: Writer): void {
+      const unique_name_values = message.values;
+      for (let i = 0; i < unique_name_values.length; ++i) {
+        writer.uint32(10);
+        writer.fork();
+        account_liquidity.encode(unique_name_values[i], writer);
+        writer.ldelim();
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_liquidity_response {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_liquidity_response();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.values.push(
+              account_liquidity.decode(reader, reader.uint32())
+            );
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    values: Array<account_liquidity>;
+
+    constructor(values: Array<account_liquidity> = []) {
+      this.values = values;
+    }
+  }
+
+  export class pool_tvl {
+    static encode(message: pool_tvl, writer: Writer): void {
+      if (message.pool.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.pool);
+      }
+
+      if (message.tvl != 0) {
+        writer.uint32(16);
+        writer.uint64(message.tvl);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): pool_tvl {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new pool_tvl();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.pool = reader.bytes();
+            break;
+
+          case 2:
+            message.tvl = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    pool: Uint8Array;
+    tvl: u64;
+
+    constructor(pool: Uint8Array = new Uint8Array(0), tvl: u64 = 0) {
+      this.pool = pool;
+      this.tvl = tvl;
+    }
+  }
+
+  export class get_tvl_request {
+    static encode(message: get_tvl_request, writer: Writer): void {
+      if (message.start.length != 0) {
+        writer.uint32(10);
+        writer.bytes(message.start);
+      }
+
+      if (message.pool.length != 0) {
+        writer.uint32(18);
+        writer.bytes(message.pool);
+      }
+
+      if (message.limit != 0) {
+        writer.uint32(24);
+        writer.uint64(message.limit);
+      }
+
+      if (message.ms != 0) {
+        writer.uint32(32);
+        writer.uint64(message.ms);
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_tvl_request {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_tvl_request();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.start = reader.bytes();
+            break;
+
+          case 2:
+            message.pool = reader.bytes();
+            break;
+
+          case 3:
+            message.limit = reader.uint64();
+            break;
+
+          case 4:
+            message.ms = reader.uint64();
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    start: Uint8Array;
+    pool: Uint8Array;
+    limit: u64;
+    ms: u64;
+
+    constructor(
+      start: Uint8Array = new Uint8Array(0),
+      pool: Uint8Array = new Uint8Array(0),
+      limit: u64 = 0,
+      ms: u64 = 0
+    ) {
+      this.start = start;
+      this.pool = pool;
+      this.limit = limit;
+      this.ms = ms;
+    }
+  }
+
+  export class get_tvl_response {
+    static encode(message: get_tvl_response, writer: Writer): void {
+      const unique_name_values = message.values;
+      for (let i = 0; i < unique_name_values.length; ++i) {
+        writer.uint32(10);
+        writer.fork();
+        pool_tvl.encode(unique_name_values[i], writer);
+        writer.ldelim();
+      }
+    }
+
+    static decode(reader: Reader, length: i32): get_tvl_response {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new get_tvl_response();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.values.push(pool_tvl.decode(reader, reader.uint32()));
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    values: Array<pool_tvl>;
+
+    constructor(values: Array<pool_tvl> = []) {
+      this.values = values;
+    }
+  }
+
+  export class koindx_tracker_request {
+    static encode(message: koindx_tracker_request, writer: Writer): void {
+      const unique_name_reserved = message.reserved;
+      if (unique_name_reserved !== null) {
+        writer.uint32(10);
+        writer.fork();
+        rpc.reserved_rpc.encode(unique_name_reserved, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_pools = message.get_pools;
+      if (unique_name_get_pools !== null) {
+        writer.uint32(18);
+        writer.fork();
+        get_pools_request.encode(unique_name_get_pools, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_liquidity = message.get_liquidity;
+      if (unique_name_get_liquidity !== null) {
+        writer.uint32(26);
+        writer.fork();
+        get_liquidity_request.encode(unique_name_get_liquidity, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_tvl = message.get_tvl;
+      if (unique_name_get_tvl !== null) {
+        writer.uint32(34);
+        writer.fork();
+        get_tvl_request.encode(unique_name_get_tvl, writer);
+        writer.ldelim();
+      }
+    }
+
+    static decode(reader: Reader, length: i32): koindx_tracker_request {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new koindx_tracker_request();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.reserved = rpc.reserved_rpc.decode(reader, reader.uint32());
+            break;
+
+          case 2:
+            message.get_pools = get_pools_request.decode(
+              reader,
+              reader.uint32()
+            );
+            break;
+
+          case 3:
+            message.get_liquidity = get_liquidity_request.decode(
+              reader,
+              reader.uint32()
+            );
+            break;
+
+          case 4:
+            message.get_tvl = get_tvl_request.decode(reader, reader.uint32());
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    reserved: rpc.reserved_rpc | null;
+    get_pools: get_pools_request | null;
+    get_liquidity: get_liquidity_request | null;
+    get_tvl: get_tvl_request | null;
+
+    constructor(
+      reserved: rpc.reserved_rpc | null = null,
+      get_pools: get_pools_request | null = null,
+      get_liquidity: get_liquidity_request | null = null,
+      get_tvl: get_tvl_request | null = null
+    ) {
+      this.reserved = reserved;
+      this.get_pools = get_pools;
+      this.get_liquidity = get_liquidity;
+      this.get_tvl = get_tvl;
+    }
+  }
+
+  export class koindx_tracker_response {
+    static encode(message: koindx_tracker_response, writer: Writer): void {
+      const unique_name_reserved = message.reserved;
+      if (unique_name_reserved !== null) {
+        writer.uint32(10);
+        writer.fork();
+        rpc.reserved_rpc.encode(unique_name_reserved, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_error = message.error;
+      if (unique_name_error !== null) {
+        writer.uint32(18);
+        writer.fork();
+        rpc.error_status.encode(unique_name_error, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_pools = message.get_pools;
+      if (unique_name_get_pools !== null) {
+        writer.uint32(26);
+        writer.fork();
+        get_pools_response.encode(unique_name_get_pools, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_liquidity = message.get_liquidity;
+      if (unique_name_get_liquidity !== null) {
+        writer.uint32(34);
+        writer.fork();
+        get_liquidity_response.encode(unique_name_get_liquidity, writer);
+        writer.ldelim();
+      }
+
+      const unique_name_get_tvl = message.get_tvl;
+      if (unique_name_get_tvl !== null) {
+        writer.uint32(42);
+        writer.fork();
+        get_tvl_response.encode(unique_name_get_tvl, writer);
+        writer.ldelim();
+      }
+    }
+
+    static decode(reader: Reader, length: i32): koindx_tracker_response {
+      const end: usize = length < 0 ? reader.end : reader.ptr + length;
+      const message = new koindx_tracker_response();
+
+      while (reader.ptr < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1:
+            message.reserved = rpc.reserved_rpc.decode(reader, reader.uint32());
+            break;
+
+          case 2:
+            message.error = rpc.error_status.decode(reader, reader.uint32());
+            break;
+
+          case 3:
+            message.get_pools = get_pools_response.decode(
+              reader,
+              reader.uint32()
+            );
+            break;
+
+          case 4:
+            message.get_liquidity = get_liquidity_response.decode(
+              reader,
+              reader.uint32()
+            );
+            break;
+
+          case 5:
+            message.get_tvl = get_tvl_response.decode(reader, reader.uint32());
+            break;
+
+          default:
+            reader.skipType(tag & 7);
+            break;
+        }
+      }
+
+      return message;
+    }
+
+    reserved: rpc.reserved_rpc | null;
+    error: rpc.error_status | null;
+    get_pools: get_pools_response | null;
+    get_liquidity: get_liquidity_response | null;
+    get_tvl: get_tvl_response | null;
+
+    constructor(
+      reserved: rpc.reserved_rpc | null = null,
+      error: rpc.error_status | null = null,
+      get_pools: get_pools_response | null = null,
+      get_liquidity: get_liquidity_response | null = null,
+      get_tvl: get_tvl_response | null = null
+    ) {
+      this.reserved = reserved;
+      this.error = error;
+      this.get_pools = get_pools;
+      this.get_liquidity = get_liquidity;
+      this.get_tvl = get_tvl;
+    }
+  }
+}
diff --git a/assembly/koinos/standards/kcs4.ts b/assembly/koinos/standards/kcs4.ts
index d568dc2..23114e3 100644
--- a/assembly/koinos/standards/kcs4.ts
+++ b/assembly/koinos/standards/kcs4.ts
@@ -751,6 +751,11 @@ export namespace kcs4 {
         writer.uint32(16);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(26);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): mint_arguments {
@@ -768,6 +773,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 3:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -779,10 +788,16 @@ export namespace kcs4 {
 
     to: Uint8Array;
     value: u64;
+    memo: string;
 
-    constructor(to: Uint8Array = new Uint8Array(0), value: u64 = 0) {
+    constructor(
+      to: Uint8Array = new Uint8Array(0),
+      value: u64 = 0,
+      memo: string = ""
+    ) {
       this.to = to;
       this.value = value;
+      this.memo = memo;
     }
   }
 
@@ -820,6 +835,11 @@ export namespace kcs4 {
         writer.uint32(16);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(26);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): burn_arguments {
@@ -837,6 +857,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 3:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -848,10 +872,16 @@ export namespace kcs4 {
 
     from: Uint8Array;
     value: u64;
+    memo: string;
 
-    constructor(from: Uint8Array = new Uint8Array(0), value: u64 = 0) {
+    constructor(
+      from: Uint8Array = new Uint8Array(0),
+      value: u64 = 0,
+      memo: string = ""
+    ) {
       this.from = from;
       this.value = value;
+      this.memo = memo;
     }
   }
 
@@ -894,6 +924,11 @@ export namespace kcs4 {
         writer.uint32(24);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(34);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): approve_arguments {
@@ -915,6 +950,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 4:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -927,15 +966,18 @@ export namespace kcs4 {
     owner: Uint8Array;
     spender: Uint8Array;
     value: u64;
+    memo: string;
 
     constructor(
       owner: Uint8Array = new Uint8Array(0),
       spender: Uint8Array = new Uint8Array(0),
-      value: u64 = 0
+      value: u64 = 0,
+      memo: string = ""
     ) {
       this.owner = owner;
       this.spender = spender;
       this.value = value;
+      this.memo = memo;
     }
   }
 
@@ -973,6 +1015,11 @@ export namespace kcs4 {
         writer.uint32(16);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(26);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): burn_event {
@@ -990,6 +1037,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 3:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -1001,10 +1052,16 @@ export namespace kcs4 {
 
     from: Uint8Array;
     value: u64;
+    memo: string;
 
-    constructor(from: Uint8Array = new Uint8Array(0), value: u64 = 0) {
+    constructor(
+      from: Uint8Array = new Uint8Array(0),
+      value: u64 = 0,
+      memo: string = ""
+    ) {
       this.from = from;
       this.value = value;
+      this.memo = memo;
     }
   }
 
@@ -1019,6 +1076,11 @@ export namespace kcs4 {
         writer.uint32(16);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(26);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): mint_event {
@@ -1036,6 +1098,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 3:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -1047,10 +1113,16 @@ export namespace kcs4 {
 
     to: Uint8Array;
     value: u64;
+    memo: string;
 
-    constructor(to: Uint8Array = new Uint8Array(0), value: u64 = 0) {
+    constructor(
+      to: Uint8Array = new Uint8Array(0),
+      value: u64 = 0,
+      memo: string = ""
+    ) {
       this.to = to;
       this.value = value;
+      this.memo = memo;
     }
   }
 
@@ -1143,6 +1215,11 @@ export namespace kcs4 {
         writer.uint32(24);
         writer.uint64(message.value);
       }
+
+      if (message.memo.length != 0) {
+        writer.uint32(34);
+        writer.string(message.memo);
+      }
     }
 
     static decode(reader: Reader, length: i32): approve_event {
@@ -1164,6 +1241,10 @@ export namespace kcs4 {
             message.value = reader.uint64();
             break;
 
+          case 4:
+            message.memo = reader.string();
+            break;
+
           default:
             reader.skipType(tag & 7);
             break;
@@ -1176,15 +1257,18 @@ export namespace kcs4 {
     owner: Uint8Array;
     spender: Uint8Array;
     value: u64;
+    memo: string;
 
     constructor(
       owner: Uint8Array = new Uint8Array(0),
       spender: Uint8Array = new Uint8Array(0),
-      value: u64 = 0
+      value: u64 = 0,
+      memo: string = ""
     ) {
       this.owner = owner;
       this.spender = spender;
       this.value = value;
+      this.memo = memo;
     }
   }
 }
diff --git a/index.ts b/index.ts
index 5a7a84c..e911e6e 100644
--- a/index.ts
+++ b/index.ts
@@ -19,6 +19,7 @@ export { p2p_rpc } from './assembly/koinos/rpc/p2p/p2p_rpc';
 export { account_history_rpc } from './assembly/koinos/rpc/account_history/account_history_rpc';
 export { transaction_store_rpc } from './assembly/koinos/rpc/transaction_store/transaction_store_rpc';
 export { chain_rpc } from './assembly/koinos/rpc/chain/chain_rpc';
+export { koindx_tracker_rpc } from './assembly/koinos/rpc/koindx_tracker/koindx_tracker_rpc';
 export { contract_meta_store_rpc } from './assembly/koinos/rpc/contract_meta_store/contract_meta_store_rpc';
 export { common } from './assembly/koinos/common';
 export { transaction_store } from './assembly/koinos/transaction_store/transaction_store';
@@ -30,6 +31,7 @@ export { object_spaces } from './assembly/koinos/chain/object_spaces';
 export { system_calls } from './assembly/koinos/chain/system_calls';
 export { system_call_ids } from './assembly/koinos/chain/system_call_ids';
 export { value } from './assembly/koinos/chain/value';
+export { koindx_tracker } from './assembly/koinos/koindx_tracker/koindx_tracker';
 export { pob } from './assembly/koinos/contracts/pob/pob';
 export { token } from './assembly/koinos/contracts/token/token';
 export { name_service } from './assembly/koinos/contracts/name_service/name_service';