@idos-network/kwil-infra 1.1.0

package/src/actions/index.ts

@@ -0,0 +1,55 @@
+import type { KwilActionClient } from "..";
+
+import {
+  type AddUserAsInserterInput,
+  type AddWalletInput,
+  addWallet,
+  type DwgMessageInput,
+  type GetAccessGrantsGrantedInput,
+  type GetAccessGrantsGrantedOutput,
+  type GetAttributesOutput,
+  type GetCredentialSharedOutput,
+  type GetCredentialsOutput,
+  getAccessGrantsGranted,
+  removeWallet,
+  type UpsertWalletAsInserterInput,
+} from "./actions";
+
+export * from "./actions";
+
+// Name aliases for a better developer experience
+export type idOSUser = AddUserAsInserterInput;
+export type idOSGrant = GetAccessGrantsGrantedOutput;
+export type idOSCredential = GetCredentialSharedOutput;
+export type idOSCredentialListItem = GetCredentialsOutput;
+export type idOSUserAttribute = GetAttributesOutput;
+export type idOSWallet = UpsertWalletAsInserterInput;
+export type idOSDelegatedWriteGrant = DwgMessageInput;
+
+export async function addWallets(
+  kwilClient: KwilActionClient,
+  wallets: AddWalletInput[],
+): Promise<void> {
+  await Promise.all(wallets.map((wallet) => addWallet(kwilClient, wallet)));
+}
+
+export async function removeWallets(kwilClient: KwilActionClient, ids: string[]): Promise<void> {
+  await Promise.all(ids.map((id) => removeWallet(kwilClient, { id })));
+}
+
+export const GET_GRANTS_DEFAULT_RECORDS_PER_PAGE = 10;
+
+export async function getGrants(
+  kwilClient: KwilActionClient,
+  params: Partial<GetAccessGrantsGrantedInput> = {
+    page: 1,
+    size: GET_GRANTS_DEFAULT_RECORDS_PER_PAGE,
+    user_id: null,
+  },
+): Promise<idOSGrant[]> {
+  return getAccessGrantsGranted(kwilClient, {
+    page: params.page ?? 1,
+    size: params.size ?? 10,
+    user_id: params.user_id ?? null,
+  });
+}

package/src/create-kwil-client.ts

@@ -0,0 +1,144 @@
+import type { Config } from "@idos-network/kwil-js/dist/api_client/config";
+import type {
+  ActionBody,
+  CallBody,
+  PositionalParams,
+} from "@idos-network/kwil-js/dist/core/action";
+import type { DataInfo } from "@idos-network/kwil-js/dist/core/database";
+
+import { type KwilSigner, NodeKwil, WebKwil } from "@idos-network/kwil-js";
+import invariant from "tiny-invariant";
+
+import type { ActionSchemaElement } from "./actions";
+
+import { actionSchema } from "./actions";
+
+type CreateKwilClientParams = {
+  chainId?: string;
+  nodeUrl: string;
+};
+
+type KwilActions = typeof actionSchema;
+type ActionName = keyof KwilActions;
+
+type AllKwilCallAction = {
+  [Name in ActionName]: {
+    name: Name;
+    // oxlint-disable-next-line typescript/no-explicit-any -- This is fine
+    inputs: Record<KwilActions[Name][number]["name"], any>;
+  };
+};
+
+type KwilCallActionRequestParams = AllKwilCallAction[ActionName];
+
+type AllKwilExecuteAction = {
+  [Name in ActionName]: AllKwilCallAction[Name] & { description: string };
+};
+
+type KwilExecuteActionRequestParams = AllKwilExecuteAction[ActionName];
+
+/**
+ * A client for interacting with kwil with type-safe abstractions for `call` and `execute`.
+ * Has utility methods for creating actions and setting a signer.
+ */
+export class KwilActionClient {
+  signer?: KwilSigner;
+  readonly client: NodeKwil | WebKwil;
+
+  constructor(client: NodeKwil | WebKwil) {
+    this.client = client;
+  }
+
+  #createActionInputs(actionName: string, params: Record<string, unknown> = {}): PositionalParams {
+    if (!params || !Object.keys(params).length) return [];
+
+    const args = (actionSchema as Record<string, readonly ActionSchemaElement[]>)[actionName];
+
+    return args.map(({ name }) => {
+      const value = params[name];
+      // Handle falsy values appropriately
+      if (value === "" || value === 0) return value;
+      return value ?? null;
+    }) as PositionalParams;
+  }
+
+  #actionTypes(actionName: string): DataInfo[] {
+    const args = actionSchema[actionName];
+    return args.map((arg) => arg.type);
+  }
+
+  /**
+   * Calls an action on the kwil nodes. This similar to `GET` like request.
+   */
+  async call<T = unknown>(
+    params: KwilCallActionRequestParams,
+    signer: KwilSigner | undefined = this.signer,
+  ): Promise<T> {
+    const action: CallBody = {
+      name: params.name,
+      namespace: "main",
+      inputs: this.#createActionInputs(params.name, params.inputs),
+      types: this.#actionTypes(params.name),
+    };
+
+    const response = await this.client.call(action as CallBody, signer);
+    return response?.data?.result as T;
+  }
+
+  /**
+   * Executes an action on the kwil nodes. This similar to `POST` like request.
+   */
+  async execute(
+    params: KwilExecuteActionRequestParams,
+    signer: KwilSigner | undefined = this.signer,
+    synchronous = true,
+  ): Promise<string | undefined> {
+    invariant(signer, "Signer is not set, you must set it before executing an action");
+    const action: ActionBody = {
+      name: params.name,
+      namespace: "main",
+      description: params.description,
+      inputs: [this.#createActionInputs(params.name, params.inputs)],
+      types: this.#actionTypes(params.name),
+    };
+    const response = await this.client.execute(action, signer, synchronous);
+    return response.data?.tx_hash;
+  }
+
+  setSigner(signer: KwilSigner | undefined): void {
+    this.signer = signer;
+  }
+
+  /**
+   * Creates action inputs from the given parameters that are used in the action body.
+   */
+}
+
+const DEFAULT_TIMEOUT = 30_000;
+
+const createKwilClient =
+  (Cls: new (opts: Config) => NodeKwil | WebKwil) =>
+  async ({ nodeUrl: kwilProvider, chainId }: CreateKwilClientParams): Promise<KwilActionClient> => {
+    const _kwil = new Cls({ kwilProvider, chainId: "" });
+    // oxlint-disable-next-line no-param-reassign -- Default value fallback
+    chainId ||= (await _kwil.chainInfo({ disableWarning: true })).data?.chain_id;
+    invariant(chainId, "Can't discover `chainId`. You must pass it explicitly.");
+
+    const client = new KwilActionClient(
+      new Cls({ kwilProvider, chainId, timeout: DEFAULT_TIMEOUT }),
+    );
+
+    return client;
+  };
+
+/**
+ * Create a kwil client for node.js environment
+ */
+export const createNodeKwilClient: (params: CreateKwilClientParams) => Promise<KwilActionClient> =
+  createKwilClient(NodeKwil);
+
+/**
+ * Create a kwil client for browser environment
+ */
+export const createWebKwilClient: (params: CreateKwilClientParams) => Promise<KwilActionClient> =
+  createKwilClient(WebKwil);

package/src/create-kwil-signer.ts

@@ -0,0 +1,270 @@
+import type { Store } from "@idos-network/utils/store";
+import type { Wallet as NearWallet } from "@near-wallet-selector/core";
+import type { Keypair as StellarKeypair } from "@stellar/stellar-sdk";
+import type { Wallet as EthersWallet, JsonRpcSigner } from "ethers";
+import type { KeyPair as NearKeyPair } from "near-api-js";
+import type { KeyPair as XrpKeyPair } from "ripple-keypairs/src/types";
+
+import { KwilSigner } from "@idos-network/kwil-js";
+import { bs58Encode, hexDecode, hexEncode } from "@idos-network/utils/codecs";
+import nacl from "tweetnacl";
+
+import type { WalletType } from "./actions";
+import type { KwilActionClient } from "./create-kwil-client";
+
+import { FaceSignSignerProvider } from "./facesign/facesign-signer";
+import {
+  createNearWalletKwilSigner,
+  implicitAddressFromPublicKey,
+  looksLikeNearWallet,
+} from "./near/create-near-wallet-kwil-signer";
+import { kwilNep413Signer } from "./near/nep413";
+import { createXrpKwilSigner } from "./xrp/signer";
+import { getXrpPublicKey, looksLikeXrpWallet } from "./xrp/utils";
+
+export { KwilSigner } from "@idos-network/kwil-js";
+export type Wallet =
+  | EthersWallet
+  | JsonRpcSigner
+  | NearWallet
+  | CustomKwilSigner
+  | FaceSignSignerProvider;
+
+/**
+ * Helper function to check if the given object is a `nacl.SignKeyPair`.
+ */
+function isNaclSignKeyPair(object: unknown): object is nacl.SignKeyPair {
+  return (
+    object !== null &&
+    typeof object === "object" &&
+    "publicKey" in object &&
+    object.publicKey instanceof Uint8Array &&
+    object.publicKey.length === nacl.sign.publicKeyLength &&
+    "secretKey" in object &&
+    object.secretKey instanceof Uint8Array &&
+    object.secretKey.length === nacl.sign.secretKeyLength
+  );
+}
+
+/**
+ * Helper function to check if the given object is a NEAR KeyPair.
+ */
+function isNearKeyPair(object: unknown): object is NearKeyPair {
+  return (
+    object !== null &&
+    typeof object === "object" &&
+    "getPublicKey" in object &&
+    "sign" in object &&
+    typeof object.getPublicKey === "function" &&
+    typeof object.sign === "function"
+  );
+}
+
+/**
+ * Helper function to check if the given object is a Stellar Keypair.
+ */
+function isStellarKeyPair(object: unknown): object is StellarKeypair {
+  return (
+    object !== null &&
+    typeof object === "object" &&
+    "publicKey" in object &&
+    "sign" in object &&
+    "canSign" in object &&
+    typeof object.publicKey === "function" &&
+    typeof object.sign === "function" &&
+    typeof object.canSign === "function"
+  );
+}
+
+export interface CustomKwilSigner extends KwilSigner {
+  publicAddress: string;
+  signatureType: string;
+  publicKey: string;
+  walletType: string;
+  signMessage: (message: Uint8Array | string) => Promise<Uint8Array>;
+}
+
+function isCustomKwilSigner(object: unknown): object is CustomKwilSigner {
+  return (
+    object !== null &&
+    typeof object === "object" &&
+    "publicAddress" in object &&
+    "signatureType" in object &&
+    "publicKey" in object &&
+    "signMessage" in object
+  );
+}
+
+/**
+ * Helper function to check if the given object is a XRP KeyPair (Server key pairs only).
+ */
+function isXrplKeyPair(object: unknown): object is XrpKeyPair {
+  return !!object && typeof object === "object" && "privateKey" in object && "publicKey" in object;
+}
+
+export type KwilSignerType =
+  | NearKeyPair
+  | EthersWallet
+  | nacl.SignKeyPair
+  | JsonRpcSigner
+  | StellarKeypair
+  | XrpKeyPair;
+
+export type SignerAddress = string;
+export type SignerPublicKey = string | undefined;
+
+/**
+ * Creates a `KwilSigner` and its associated `SignerAddress`.
+ *
+ * This function is explicitly marked as being for backend use only because it doesn't reset
+ * the KGW cookie when logging out and re-logging in with a different wallet.
+ */
+export async function createServerKwilSigner(
+  signer: KwilSignerType,
+): Promise<[KwilSigner, SignerAddress]> {
+  if (isNaclSignKeyPair(signer)) {
+    return [
+      new KwilSigner(
+        async (msg: Uint8Array) => nacl.sign.detached(msg, signer.secretKey),
+        signer.publicKey,
+        "ed25519",
+      ),
+      implicitAddressFromPublicKey(bs58Encode(signer.publicKey)),
+    ];
+  }
+
+  if (isNearKeyPair(signer)) {
+    const publicKey = implicitAddressFromPublicKey(signer.getPublicKey().toString());
+    return [
+      new KwilSigner(kwilNep413Signer("idos-issuer")(signer), publicKey, "nep413"),
+      publicKey,
+    ];
+  }
+
+  if (isStellarKeyPair(signer)) {
+    const publicKeyString = signer.publicKey();
+    const rawPublicKey = signer.rawPublicKey();
+    return [
+      new KwilSigner(
+        async (msg: Uint8Array) => signer.sign(Buffer.from(msg)),
+        rawPublicKey,
+        "ed25519",
+      ),
+      publicKeyString,
+    ];
+  }
+
+  if (isXrplKeyPair(signer)) {
+    let xrpKeypair: typeof import("ripple-keypairs");
+
+    try {
+      xrpKeypair = await import("ripple-keypairs");
+    } catch (e) {
+      throw new Error("Can't load ripple-keypairs", { cause: e });
+    }
+
+    return [
+      new KwilSigner(
+        async (msg: Uint8Array) => hexDecode(xrpKeypair.sign(hexEncode(msg), signer.privateKey)),
+        signer.publicKey,
+        "xrpl",
+      ),
+      signer.publicKey,
+    ];
+  }
+
+  if ("address" in signer) {
+    return [new KwilSigner(signer, signer.address), signer.address];
+  }
+
+  // Force the check that `signer` is never.
+  // If these lines start complaining, that means we're missing an `if` above.
+  return ((_: never) => {
+    throw new Error("Invalid `signer` type");
+  })(signer);
+}
+
+export async function createClientKwilSigner(
+  store: Store,
+  kwilClient: KwilActionClient,
+  wallet: Wallet,
+): Promise<[KwilSigner, SignerAddress, SignerPublicKey, WalletType]> {
+  if ("connect" in wallet && "address" in wallet) {
+    // oxlint-disable-next-line no-param-reassign -- Narrowing the type on purpose
+    wallet = wallet as unknown as JsonRpcSigner;
+    const currentAddress = await wallet.getAddress();
+
+    const storedAddress = await store.get<string>("signer-address");
+
+    if (storedAddress !== currentAddress) {
+      // To avoid re-using the old signer's kgw cookie.
+      // When kwil-js supports multi cookies, we can remove this.
+      store.set("signer-address", currentAddress);
+      try {
+        await kwilClient.client.auth.logoutKGW();
+      } catch (error) {
+        console.log("error logoutKGW", error);
+      }
+    }
+
+    return [new KwilSigner(wallet, currentAddress), currentAddress, undefined, "EVM"];
+  }
+
+  if (looksLikeNearWallet(wallet)) {
+    const accounts = await wallet.getAccounts();
+    const { kwilSigner, publicKey } = await createNearWalletKwilSigner(
+      wallet,
+      accounts[0].accountId,
+      store,
+      kwilClient,
+    );
+
+    return [kwilSigner, accounts[0].accountId, publicKey, "NEAR"];
+  }
+
+  if (looksLikeXrpWallet(wallet)) {
+    const { address: currentAddress, publicKey: walletPublicKey } = (await getXrpPublicKey(
+      wallet,
+    )) as { address: string; publicKey: string };
+    if (!currentAddress) {
+      throw new Error("Failed to get XRP address");
+    }
+
+    return [
+      await createXrpKwilSigner(wallet, currentAddress, store, kwilClient, walletPublicKey),
+      currentAddress,
+      walletPublicKey,
+      "XRPL",
+    ];
+  }
+
+  if (isCustomKwilSigner(wallet) || wallet instanceof FaceSignSignerProvider) {
+    const storedAddress = await store.get<string>("signer-address");
+
+    if (storedAddress !== wallet.publicAddress) {
+      store.set("signer-address", wallet.publicAddress);
+      try {
+        await kwilClient.client.auth.logoutKGW();
+      } catch (error) {
+        console.log("error logoutKGW", error);
+      }
+    }
+
+    return [
+      new KwilSigner(
+        async (msg: Uint8Array) => wallet.signMessage(msg),
+        wallet.publicAddress,
+        "ed25519",
+      ),
+      wallet.publicAddress,
+      wallet.publicKey,
+      wallet.walletType as WalletType,
+    ];
+  }
+
+  // Force the check that `signer` is `never`.
+  // If these lines start complaining, that means we're missing an `if` above.
+  return ((_: never) => {
+    throw new Error("Invalid `signer` type");
+  })(wallet);
+}