@gnolang/gnonative 0.1.2

package/src/grpc/transport_native.ts

@@ -0,0 +1,197 @@
+import type { AnyMessage, MethodInfo, PartialMessage, ServiceType } from '@bufbuild/protobuf';
+import { Message, MethodKind } from '@bufbuild/protobuf';
+import type {
+  ContextValues,
+  StreamResponse,
+  Transport,
+  UnaryRequest,
+  UnaryResponse,
+} from '@connectrpc/connect';
+import { createContextValues } from '@connectrpc/connect';
+import {
+  createClientMethodSerializers,
+  createMethodUrl,
+  runStreamingCall,
+  runUnaryCall,
+} from '@connectrpc/connect/protocol';
+import { requestHeader } from '@connectrpc/connect/protocol-grpc-web';
+import { GrpcWebTransportOptions } from '@connectrpc/connect-web';
+import { CodedError } from 'expo-modules-core';
+import { decode } from 'js-base64';
+
+import { GoBridge } from '../GoBridge';
+
+function base64ToBytes(base64: string): Uint8Array {
+  const binString = decode(base64);
+  const bytes = new Uint8Array(binString.length);
+
+  for (let i = 0; i < binString.length; i++) {
+    bytes[i] = binString.charCodeAt(i);
+  }
+
+  return bytes;
+}
+
+export function createNativeGrpcTransport(options: GrpcWebTransportOptions): Transport {
+  const useBinaryFormat = options.useBinaryFormat ?? true;
+  return {
+    async unary<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage>(
+      service: ServiceType,
+      method: MethodInfo<I, O>,
+      signal: AbortSignal | undefined,
+      timeoutMs: number | undefined,
+      header: HeadersInit | undefined,
+      message: PartialMessage<I>,
+      contextValues?: ContextValues,
+    ): Promise<UnaryResponse<I, O>> {
+      const { parse } = createClientMethodSerializers(
+        method,
+        useBinaryFormat,
+        options.jsonOptions,
+        options.binaryOptions,
+      );
+
+      return await runUnaryCall<I, O>({
+        signal,
+        interceptors: options.interceptors,
+        req: {
+          stream: false,
+          service,
+          method,
+          url: createMethodUrl(options.baseUrl, service, method),
+          init: {
+            method: 'POST',
+            mode: 'cors',
+          },
+          header: new Headers(),
+          contextValues: contextValues ?? createContextValues(),
+          message,
+        },
+        next: async (req: UnaryRequest<I, O>): Promise<UnaryResponse<I, O>> => {
+          try {
+            const res = await GoBridge.invokeGrpcMethod(
+              req.method.name,
+              req.message.toJsonString(),
+            );
+
+            const header: Headers | undefined = new Headers();
+            const trailer: Headers | undefined = new Headers();
+
+            const data = base64ToBytes(res);
+            const message = parse(data);
+
+            return <UnaryResponse<I, O>>{
+              stream: false,
+              service,
+              method,
+              header,
+              message,
+              trailer,
+            };
+          } catch (e) {
+            console.log('next: unary call error:', e);
+            throw e;
+          }
+        },
+      });
+    },
+
+    async stream<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage>(
+      service: ServiceType,
+      method: MethodInfo<I, O>,
+      signal: AbortSignal | undefined,
+      timeoutMs: number | undefined,
+      header: HeadersInit | undefined,
+      input: AsyncIterable<PartialMessage<I>>,
+      contextValues?: ContextValues,
+    ): Promise<StreamResponse<I, O>> {
+      const { parse } = createClientMethodSerializers(
+        method,
+        useBinaryFormat,
+        options.jsonOptions,
+        options.binaryOptions,
+      );
+
+      async function createRequestBody(input: AsyncIterable<I>): Promise<string> {
+        if (method.kind !== MethodKind.ServerStreaming) {
+          throw 'The fetch API does not support streaming request bodies';
+        }
+
+        const r = await input[Symbol.asyncIterator]().next();
+        if (r.done === true) {
+          throw 'missing request message';
+        }
+
+        return r.value.toJsonString();
+      }
+
+      return await runStreamingCall<I, O>({
+        interceptors: options.interceptors,
+        timeoutMs,
+        signal,
+        req: {
+          stream: true,
+          service,
+          method,
+          url: createMethodUrl(options.baseUrl, service, method),
+          init: {
+            method: 'POST',
+            credentials: options.credentials ?? 'same-origin',
+            mode: 'cors',
+          },
+          header: requestHeader(useBinaryFormat, timeoutMs, header, false),
+          message: input,
+          contextValues: contextValues ?? createContextValues(),
+        },
+        next: async req => {
+          const header: Headers | undefined = new Headers();
+          const trailer: Headers | undefined = new Headers();
+
+          const body = await createRequestBody(req.message);
+
+          let streamId: string;
+          try {
+            streamId = await GoBridge.createStreamClient(req.method.name, body);
+          } catch (e) {
+            console.log('createStreamClient error:', e);
+            throw e;
+          }
+
+          const generator = {
+            async *[Symbol.asyncIterator]() {
+              for (; ;) {
+                try {
+                  const res = await GoBridge.streamClientReceive(streamId);
+                  const data = base64ToBytes(res);
+                  const message = parse(data);
+                  yield message;
+                } catch (e) {
+                  // close the stream
+                  try {
+                    await GoBridge.closeStreamClient(streamId);
+                  } catch (e) {
+                    console.log('closeStreamClient error:', e);
+                  }
+
+                  if (!(e instanceof CodedError && e.message === 'EOF')) {
+                    console.log('streamClientReceive error:', e);
+                    throw e;
+                  }
+                  break;
+                }
+              }
+            },
+          };
+
+          const res: StreamResponse<I, O> = {
+            ...req,
+            header,
+            trailer,
+            message: generator,
+          };
+          return res;
+        },
+      });
+    },
+  };
+}

package/src/hooks/types.ts

@@ -0,0 +1,19 @@
+import { KeyInfo } from '@buf/gnolang_gnonative.bufbuild_es/gnonativetypes_pb';
+
+export type GnoConfig = {
+  Remote: string;
+  ChainID: string;
+  KeyName: string;
+  Password: string;
+  GasFee: string;
+  GasWanted: number;
+  Mnemonic: string;
+};
+
+export type NetworkMetainfo = {
+  chainId: string;
+  chainName: string;
+  gnoAddress: string;
+};
+
+export type GnoAccount = KeyInfo;

package/src/hooks/use-gno.ts

@@ -0,0 +1,423 @@
+import {
+  AddressFromBech32Request,
+  AddressToBech32Request,
+  CallRequest,
+  CallResponse,
+  CreateAccountRequest,
+  DeleteAccountRequest,
+  DeleteAccountResponse,
+  GenerateRecoveryPhraseRequest,
+  GetActiveAccountRequest,
+  GetActiveAccountResponse,
+  GetChainIDRequest,
+  GetKeyInfoByAddressRequest,
+  GetKeyInfoByNameOrAddressRequest,
+  GetKeyInfoByNameRequest,
+  GetRemoteRequest,
+  HasKeyByAddressRequest,
+  HasKeyByNameOrAddressRequest,
+  HasKeyByNameRequest,
+  HelloRequest,
+  HelloStreamResponse,
+  ListKeyInfoRequest,
+  MsgCall,
+  MsgSend,
+  QEvalRequest,
+  QueryAccountRequest,
+  QueryAccountResponse,
+  QueryRequest,
+  QueryResponse,
+  RenderRequest,
+  SelectAccountRequest,
+  SelectAccountResponse,
+  SendRequest,
+  SendResponse,
+  SetChainIDRequest,
+  SetChainIDResponse,
+  SetPasswordRequest,
+  SetPasswordResponse,
+  SetRemoteRequest,
+  SetRemoteResponse,
+} from '@buf/gnolang_gnonative.bufbuild_es/gnonativetypes_pb';
+import { GnoNativeService } from '@buf/gnolang_gnonative.connectrpc_es/rpc_connect';
+import { PromiseClient } from '@connectrpc/connect';
+
+import { GnoAccount } from './types';
+import { GoBridge } from '../GoBridge';
+import * as Grpc from '../grpc/client';
+
+export interface GnoResponse {
+  setRemote: (remote: string) => Promise<SetRemoteResponse>;
+  getRemote: () => Promise<string>;
+  setChainID: (chainId: string) => Promise<SetChainIDResponse>;
+  getChainID: () => Promise<string>;
+  createAccount: (
+    nameOrBech32: string,
+    mnemonic: string,
+    password: string,
+  ) => Promise<GnoAccount | undefined>;
+  generateRecoveryPhrase: () => Promise<string>;
+  listKeyInfo: () => Promise<GnoAccount[]>;
+  hasKeyByName: (name: string) => Promise<boolean>;
+  hasKeyByAddress: (address: Uint8Array) => Promise<boolean>;
+  hasKeyByNameOrAddress: (nameOrBech32: string) => Promise<boolean>;
+  getKeyInfoByName: (name: string) => Promise<GnoAccount | undefined>;
+  getKeyInfoByAddress: (address: Uint8Array) => Promise<GnoAccount | undefined>;
+  getKeyInfoByNameOrAddress: (nameOrBech32: string) => Promise<GnoAccount | undefined>;
+  selectAccount: (nameOrBech32: string) => Promise<SelectAccountResponse>;
+  setPassword: (password: string) => Promise<SetPasswordResponse>;
+  getActiveAccount: () => Promise<GetActiveAccountResponse>;
+  queryAccount: (address: Uint8Array) => Promise<QueryAccountResponse>;
+  deleteAccount: (
+    nameOrBech32: string,
+    password: string | undefined,
+    skipPassword: boolean,
+  ) => Promise<DeleteAccountResponse>;
+  query: (path: string, data: Uint8Array) => Promise<QueryResponse>;
+  render: (packagePath: string, args: string) => Promise<string>;
+  qEval: (packagePath: string, expression: string) => Promise<string>;
+  call: (
+    packagePath: string,
+    fnc: string,
+    args: Array<string>,
+    gasFee: string,
+    gasWanted: number,
+    send?: string,
+    memo?: string,
+  ) => Promise<AsyncIterable<CallResponse>>;
+  send: (
+    toAddress: Uint8Array,
+    send: string,
+    gasFee: string,
+    gasWanted: number,
+    memo?: string,
+  ) => Promise<AsyncIterable<SendResponse>>;
+  addressToBech32: (address: Uint8Array) => Promise<string>;
+  addressFromBech32: (bech32Address: string) => Promise<Uint8Array>;
+  closeBridge: () => Promise<void>;
+  initBridge: () => Promise<void>;
+  // debug
+  hello: (name: string) => Promise<string>;
+  helloStream: (name: string) => Promise<AsyncIterable<HelloStreamResponse>>;
+}
+
+let clientInstance: PromiseClient<typeof GnoNativeService> | undefined = undefined;
+let bridgeInstance: boolean = false;
+
+export const useGno = (): GnoResponse => {
+  const getClient = async () => {
+    if (!bridgeInstance) {
+      await initBridge();
+    }
+
+    if (clientInstance) return clientInstance;
+
+    console.log('Creating GRPC client instance...');
+
+    const port = await GoBridge.getTcpPort();
+    clientInstance = Grpc.createClient(port);
+
+    console.log('Creating GRPC client instance... done.');
+
+    // Set the initial configuration where it's different from the default.
+    await clientInstance.setRemote(new SetRemoteRequest({ remote: 'gno.land:26657' }));
+    await clientInstance.setChainID(new SetChainIDRequest({ chainId: 'portal-loop' }));
+
+    return clientInstance;
+  };
+
+  const closeBridge = async () => {
+    if (bridgeInstance) {
+      console.log('Closing bridge...');
+      await GoBridge.closeBridge();
+      console.log('Bridge closed.');
+      bridgeInstance = false;
+    }
+  };
+
+  const initBridge = async () => {
+    if (!bridgeInstance) {
+      console.log('Initializing bridge...');
+      await GoBridge.initBridge();
+      console.log('Bridge initialized.');
+      bridgeInstance = true;
+    }
+  };
+
+  const setRemote = async (remote: string) => {
+    const client = await getClient();
+    const response = await client.setRemote(new SetRemoteRequest({ remote }));
+    return response;
+  };
+
+  const getRemote = async () => {
+    const client = await getClient();
+    const response = await client.getRemote(new GetRemoteRequest());
+    return response.remote;
+  };
+
+  const setChainID = async (chainId: string) => {
+    const client = await getClient();
+    const response = await client.setChainID(new SetChainIDRequest({ chainId }));
+    return response;
+  };
+
+  const getChainID = async () => {
+    const client = await getClient();
+    const response = await client.getChainID(new GetChainIDRequest());
+    return response.chainId;
+  };
+
+  const createAccount = async (nameOrBech32: string, mnemonic: string, password: string) => {
+    const client = await getClient();
+    const reponse = await client.createAccount(
+      new CreateAccountRequest({
+        nameOrBech32,
+        mnemonic,
+        password,
+      }),
+    );
+    return reponse.key;
+  };
+
+  const generateRecoveryPhrase = async () => {
+    const client = await getClient();
+    const response = await client.generateRecoveryPhrase(new GenerateRecoveryPhraseRequest());
+    return response.phrase;
+  };
+
+  const hasKeyByName = async (name: string) => {
+    const client = await getClient();
+    const response = await client.hasKeyByName(new HasKeyByNameRequest({ name }));
+    return response.has;
+  };
+
+  const hasKeyByAddress = async (address: Uint8Array) => {
+    const client = await getClient();
+    const response = await client.hasKeyByAddress(new HasKeyByAddressRequest({ address }));
+    return response.has;
+  };
+
+  const hasKeyByNameOrAddress = async (nameOrBech32: string) => {
+    const client = await getClient();
+    const response = await client.hasKeyByNameOrAddress(
+      new HasKeyByNameOrAddressRequest({ nameOrBech32 }),
+    );
+    return response.has;
+  };
+
+  const getKeyInfoByName = async (name: string) => {
+    const client = await getClient();
+    const response = await client.getKeyInfoByName(new GetKeyInfoByNameRequest({ name }));
+    return response.key;
+  };
+
+  const getKeyInfoByAddress = async (address: Uint8Array) => {
+    const client = await getClient();
+    const response = await client.getKeyInfoByAddress(new GetKeyInfoByAddressRequest({ address }));
+    return response.key;
+  };
+
+  const getKeyInfoByNameOrAddress = async (nameOrBech32: string) => {
+    const client = await getClient();
+    const response = await client.getKeyInfoByNameOrAddress(
+      new GetKeyInfoByNameOrAddressRequest({ nameOrBech32 }),
+    );
+    return response.key;
+  };
+
+  const listKeyInfo = async () => {
+    const client = await getClient();
+    const response = await client.listKeyInfo(new ListKeyInfoRequest());
+    return response.keys;
+  };
+
+  const selectAccount = async (nameOrBech32: string) => {
+    const client = await getClient();
+    const response = await client.selectAccount(
+      new SelectAccountRequest({
+        nameOrBech32,
+      }),
+    );
+    return response;
+  };
+
+  const setPassword = async (password: string) => {
+    const client = await getClient();
+    const response = await client.setPassword(new SetPasswordRequest({ password }));
+    return response;
+  };
+
+  const getActiveAccount = async () => {
+    const client = await getClient();
+    const response = await client.getActiveAccount(new GetActiveAccountRequest());
+    return response;
+  };
+
+  const queryAccount = async (address: Uint8Array) => {
+    const client = await getClient();
+    const reponse = await client.queryAccount(new QueryAccountRequest({ address }));
+    return reponse;
+  };
+
+  const deleteAccount = async (
+    nameOrBech32: string,
+    password: string | undefined,
+    skipPassword: boolean,
+  ) => {
+    const client = await getClient();
+    const response = await client.deleteAccount(
+      new DeleteAccountRequest({
+        nameOrBech32,
+        password,
+        skipPassword,
+      }),
+    );
+    return response;
+  };
+
+  const query = async (path: string, data: Uint8Array) => {
+    const client = await getClient();
+    const reponse = await client.query(
+      new QueryRequest({
+        path,
+        data,
+      }),
+    );
+    return reponse;
+  };
+
+  const render = async (packagePath: string, args: string) => {
+    const client = await getClient();
+    const reponse = await client.render(
+      new RenderRequest({
+        packagePath,
+        args,
+      }),
+    );
+    return reponse.result;
+  };
+
+  const qEval = async (packagePath: string, expression: string) => {
+    const client = await getClient();
+    const reponse = await client.qEval(
+      new QEvalRequest({
+        packagePath,
+        expression,
+      }),
+    );
+    return reponse.result;
+  };
+
+  const call = async (
+    packagePath: string,
+    fnc: string,
+    args: Array<string>,
+    gasFee: string,
+    gasWanted: number,
+    send?: string,
+    memo?: string,
+  ) => {
+    const client = await getClient();
+    const reponse = client.call(
+      new CallRequest({
+        gasFee,
+        gasWanted: BigInt(gasWanted),
+        memo,
+        msgs: [
+          new MsgCall({
+            packagePath,
+            fnc,
+            args,
+            send,
+          }),
+        ],
+      }),
+    );
+    return reponse;
+  };
+
+  const send = async (
+    toAddress: Uint8Array,
+    send: string,
+    gasFee: string,
+    gasWanted: number,
+    memo?: string,
+  ) => {
+    const client = await getClient();
+    const reponse = client.send(
+      new SendRequest({
+        gasFee,
+        gasWanted: BigInt(gasWanted),
+        memo,
+        msgs: [
+          new MsgSend({
+            toAddress,
+            send,
+          }),
+        ],
+      }),
+    );
+    return reponse;
+  };
+
+  const addressToBech32 = async (address: Uint8Array) => {
+    const client = await getClient();
+    const response = await client.addressToBech32(new AddressToBech32Request({ address }));
+    return response.bech32Address;
+  };
+
+  const addressFromBech32 = async (bech32Address: string) => {
+    const client = await getClient();
+    const response = await client.addressFromBech32(
+      new AddressFromBech32Request({ bech32Address }),
+    );
+    return response.address;
+  };
+
+  // debug
+  const hello = async (name: string) => {
+    const client = await getClient();
+    const response = await client.hello(new HelloRequest({ name }));
+    return response.greeting;
+  };
+
+  // debug
+  const helloStream = async (name: string) => {
+    const client = await getClient();
+    return client.helloStream(new HelloRequest({ name }));
+  };
+
+  return {
+    initBridge,
+    closeBridge,
+    setRemote,
+    getRemote,
+    setChainID,
+    getChainID,
+    createAccount,
+    generateRecoveryPhrase,
+    listKeyInfo,
+    hasKeyByName,
+    hasKeyByAddress,
+    hasKeyByNameOrAddress,
+    getKeyInfoByName,
+    getKeyInfoByAddress,
+    getKeyInfoByNameOrAddress,
+    selectAccount,
+    setPassword,
+    getActiveAccount,
+    queryAccount,
+    deleteAccount,
+    query,
+    render,
+    qEval,
+    call,
+    send,
+    addressToBech32,
+    addressFromBech32,
+    // debug
+    hello,
+    helloStream,
+  };
+};

package/src/index.ts

@@ -0,0 +1,20 @@
+import { EventEmitter, NativeModulesProxy, Subscription } from 'expo-modules-core';
+
+// Import the native module. On web, it will be resolved to Gnonative.web.ts
+// and on native platforms to Gnonative.ts
+import { ChangeEventPayload, GnonativeViewProps } from './Gnonative.types';
+import GnonativeModule from './GnonativeModule';
+import GnonativeView from './GnonativeView';
+import 'fast-text-encoding';
+
+(Symbol as any).asyncIterator = Symbol.asyncIterator || Symbol.for('Symbol.asyncIterator');
+
+const emitter = new EventEmitter(GnonativeModule ?? NativeModulesProxy.Gnonative);
+
+export function addChangeListener(listener: (event: ChangeEventPayload) => void): Subscription {
+  return emitter.addListener<ChangeEventPayload>('onChange', listener);
+}
+
+export { ChangeEventPayload, GnonativeView, GnonativeViewProps };
+export { useGno } from './hooks/use-gno';
+export * from '@buf/gnolang_gnonative.bufbuild_es/gnonativetypes_pb';

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}