[ts-sdk] Implement getOwnedObjects

sdk/typescript/package.json

@@ -56,6 +56,8 @@
   "dependencies": {
     "bn.js": "^5.2.0",
     "buffer": "^6.0.3",
+    "jayson": "^3.6.6",
+    "superstruct": "^0.15.4",
     "tweetnacl": "^1.0.3",
     "util": "^0.12.4"
   },

sdk/typescript/src/providers/json-rpc-provider.ts

@@ -7,10 +7,11 @@ import {
   SignedTransaction,
   TransactionResponse,
 } from './provider';
+import { JsonRpcClient } from '../rpc/client';
+import { array, type as pick } from 'superstruct';
 
 export class JsonRpcProvider extends Provider {
-  //@ts-ignore
-  private endpointURL: string;
+  private client: JsonRpcClient;
 
   /**
    * Establish a connection to a Sui Gateway endpoint
@@ -19,13 +20,23 @@ export class JsonRpcProvider extends Provider {
    */
   constructor(endpoint: string) {
     super();
-    this.endpointURL = endpoint;
+    this.client = new JsonRpcClient(endpoint);
   }
 
   // Objects
-  async getObjectRefs(_address: string): Promise<ObjectRef[]> {
-    // TODO: implement the function with a RPC client
-    return [];
+  async getOwnedObjectRefs(address: string): Promise<ObjectRef[]> {
+    try {
+      const resp = await this.client.requestWithType(
+        'sui_getOwnedObjects',
+        [address],
+        pick({ objects: array(ObjectRef) })
+      );
+      return resp.objects;
+    } catch (err) {
+      throw new Error(
+        `Error fetching owned object refs: ${err} for address ${address}`
+      );
+    }
   }
 
   // Transactions

sdk/typescript/src/providers/provider.ts

@@ -1,13 +1,11 @@
 // Copyright (c) 2022, Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+import { type as pick, string, Infer, number } from 'superstruct';
+
 ///////////////////////////////
 // Exported Types
-export interface ObjectRef {
-  objectDigest: string;
-  objectId: string;
-  version: string;
-}
+export type ObjectRef = Infer<typeof ObjectRef>;
 
 export interface SignedTransaction {
   txBytes: string;
@@ -22,7 +20,7 @@ export type TransactionResponse = string;
 // Exported Abstracts
 export abstract class Provider {
   // Objects
-  abstract getObjectRefs(address: string): Promise<ObjectRef[]>;
+  abstract getOwnedObjectRefs(address: string): Promise<ObjectRef[]>;
 
   // Transactions
   abstract executeTransaction(
@@ -31,3 +29,9 @@ export abstract class Provider {
 
   // TODO: add more interface methods
 }
+
+export const ObjectRef = pick({
+  digest: string(),
+  objectId: string(),
+  version: number(),
+});

sdk/typescript/src/providers/void-provider.ts

@@ -10,8 +10,8 @@ import {
 
 export class VoidProvider extends Provider {
   // Objects
-  async getObjectRefs(_address: string): Promise<ObjectRef[]> {
-    throw this.newError('getObjectRefs');
+  async getOwnedObjectRefs(_address: string): Promise<ObjectRef[]> {
+    throw this.newError('getOwnedObjectRefs');
   }
 
   // Transactions

sdk/typescript/src/rpc/client.ts

@@ -0,0 +1,100 @@
+// Copyright (c) 2022, Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import RpcClient from 'jayson/lib/client/browser';
+import {
+  literal,
+  type as pick,
+  string,
+  Struct,
+  unknown,
+  assert,
+  optional,
+  any,
+  is,
+} from 'superstruct';
+
+/**
+ * An object defining headers to be passed to the RPC server
+ */
+export type HttpHeaders = { [header: string]: string };
+
+export class JsonRpcClient {
+  private rpcClient: RpcClient;
+
+  constructor(url: string, httpHeaders?: HttpHeaders) {
+    this.rpcClient = this.createRpcClient(url, httpHeaders);
+  }
+
+  private createRpcClient(url: string, httpHeaders?: HttpHeaders): RpcClient {
+    const client = new RpcClient(async (request, callback) => {
+      const options = {
+        method: 'POST',
+        body: request,
+        headers: Object.assign(
+          {
+            'Content-Type': 'application/json',
+          },
+          httpHeaders || {}
+        ),
+      };
+
+      try {
+        let res: Response = await fetch(url, options);
+        const text = await res.text();
+        if (res.ok) {
+          callback(null, text);
+        } else {
+          callback(new Error(`${res.status} ${res.statusText}: ${text}`));
+        }
+      } catch (err) {
+        if (err instanceof Error) callback(err);
+      }
+    }, {});
+
+    return client;
+  }
+
+  async requestWithType<T, S>(
+    method: string,
+    args: Array<any>,
+    schema: Struct<T, S>
+  ): Promise<T> {
+    const response = await this.request(method, args);
+    if (is(response, ErrorResponse)) {
+      throw new Error(`RPC Error: ${response.error.message}`);
+    } else if (is(response, ValidResponse)) {
+      assert(response.result, schema);
+      return response.result;
+    }
+    throw new Error(`Unexpected RPC Response: ${response}`);
+  }
+
+  async request(method: string, args: Array<any>): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.rpcClient.request(method, args, (err: any, response: any) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(response);
+      });
+    });
+  }
+}
+
+const ValidResponse = pick({
+  jsonrpc: literal('2.0'),
+  id: string(),
+  result: unknown(),
+});
+
+const ErrorResponse = pick({
+  jsonrpc: literal('2.0'),
+  id: string(),
+  error: pick({
+    code: unknown(),
+    message: string(),
+    data: optional(any()),
+  }),
+});