@lfdecentralizedtrust/paladin-sdk 0.13.0-rc.1

package/src/domains/zeto.ts

@@ -0,0 +1,282 @@
+import { TransactionType } from "../interfaces";
+import PaladinClient from "../paladin";
+import { TransactionFuture } from "../transaction";
+import { PaladinVerifier } from "../verifier";
+import * as zetoPrivateJSON from "./abis/IZetoFungible.json";
+import * as zetoPublicJSON from "./abis/Zeto_Anon.json";
+
+// Algorithm/verifier types specific to Zeto
+export const algorithmZetoSnarkBJJ = (domainName: string) =>
+  `domain:${domainName}:snark:babyjubjub`;
+export const IDEN3_PUBKEY_BABYJUBJUB_COMPRESSED_0X =
+  "iden3_pubkey_babyjubjub_compressed_0x";
+
+const zetoAbi = zetoPrivateJSON.abi;
+const zetoPublicAbi = zetoPublicJSON.abi;
+
+export const zetoConstructorABI = {
+  type: "constructor",
+  inputs: [{ name: "tokenName", type: "string" }],
+};
+
+export interface ZetoConstructorParams {
+  tokenName: string;
+}
+
+export interface ZetoMintParams {
+  mints: ZetoTransfer[];
+}
+
+export interface ZetoTransferParams {
+  transfers: ZetoTransfer[];
+}
+
+export interface ZetoLockParams {
+  amount: number;
+  delegate: string;
+}
+
+export interface ZetoTransferLockedParams {
+  lockedInputs: string[];
+  delegate: string;
+  transfers: ZetoTransfer[];
+}
+
+export interface ZetoDelegateLockParams {
+  utxos: string[];
+  delegate: string;
+}
+
+export interface ZetoSetERC20Params {
+  erc20: string;
+}
+
+export interface ZetoTransfer {
+  to: PaladinVerifier;
+  amount: string | number;
+  data: string;
+}
+
+export interface ZetoDepositParams {
+  amount: string | number;
+}
+
+export interface ZetoWithdrawParams {
+  amount: string | number;
+}
+
+export interface ZetoBalanceOfParams {
+  account: string;
+}
+
+export interface ZetoBalanceOfResult {
+  totalBalance: string;
+  totalStates: string;
+  overflow: boolean;
+}
+
+// Represents an in-flight Zeto deployment
+export class ZetoFuture extends TransactionFuture {
+  async waitForDeploy(waitMs?: number) {
+    const receipt = await this.waitForReceipt(waitMs);
+    return receipt?.contractAddress
+      ? new ZetoInstance(this.paladin, receipt.contractAddress)
+      : undefined;
+  }
+}
+
+export class ZetoFactory {
+  constructor(private paladin: PaladinClient, public readonly domain: string) {}
+
+  using(paladin: PaladinClient) {
+    return new ZetoFactory(paladin, this.domain);
+  }
+
+  newZeto(from: PaladinVerifier, data: ZetoConstructorParams) {
+    return new ZetoFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        domain: this.domain,
+        abi: [zetoConstructorABI],
+        function: "",
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+}
+
+export class ZetoInstance {
+  private erc20?: string;
+
+  constructor(
+    private paladin: PaladinClient,
+    public readonly address: string
+  ) {}
+
+  using(paladin: PaladinClient) {
+    const zeto = new ZetoInstance(paladin, this.address);
+    zeto.erc20 = this.erc20;
+    return zeto;
+  }
+
+  mint(from: PaladinVerifier, data: ZetoMintParams) {
+    const params = {
+      mints: data.mints.map((t) => ({ ...t, to: t.to.lookup })),
+    };
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "mint",
+        to: this.address,
+        from: from.lookup,
+        data: params,
+      })
+    );
+  }
+
+  transfer(from: PaladinVerifier, data: ZetoTransferParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "transfer",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          transfers: data.transfers.map((t) => ({ ...t, to: t.to.lookup })),
+        },
+      })
+    );
+  }
+
+  transferLocked(from: PaladinVerifier, data: ZetoTransferLockedParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "transferLocked",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          lockedInputs: data.lockedInputs,
+          delegate: data.delegate,
+          transfers: data.transfers.map((t) => ({ ...t, to: t.to.lookup })),
+        },
+      })
+    );
+  }
+
+  prepareTransferLocked(from: PaladinVerifier, data: ZetoTransferLockedParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.prepareTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "transferLocked",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          lockedInputs: data.lockedInputs,
+          delegate: data.delegate,
+          transfers: data.transfers.map((t) => ({ ...t, to: t.to.lookup })),
+        },
+      })
+    );
+  }
+
+  lock(from: PaladinVerifier, data: ZetoLockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "lock",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  delegateLock(from: PaladinVerifier, data: ZetoDelegateLockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.Public,
+        abi: zetoPublicAbi,
+        function: "delegateLock",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          data: "0x",
+          utxos: data.utxos,
+          delegate: data.delegate,
+        },
+      })
+    );
+  }
+
+  setERC20(from: PaladinVerifier, data: ZetoSetERC20Params) {
+    this.erc20 = data.erc20;
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PUBLIC,
+        abi: zetoAbi,
+        function: "setERC20",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  deposit(from: PaladinVerifier, data: ZetoDepositParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "deposit",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  withdraw(from: PaladinVerifier, data: ZetoWithdrawParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: zetoAbi,
+        function: "withdraw",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  async balanceOf(
+    from: PaladinVerifier,
+    data: ZetoBalanceOfParams
+  ): Promise<ZetoBalanceOfResult> {
+    return await this.paladin.call({
+      type: TransactionType.PRIVATE,
+      domain: "zeto",
+      abi: zetoPrivateJSON.abi,
+      function: "balanceOf",
+      to: this.address,
+      from: from.lookup,
+      data,
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import PaladinClient from "./paladin";
+export default PaladinClient;
+
+export * from "./interfaces/index";
+export * from "./utils";
+export * from "./verifier";
+export * from "./websocket";
+export * from "./domains/noto";
+export * from "./domains/pente";
+export * from "./domains/zeto";

package/src/interfaces/algorithms.ts

@@ -0,0 +1,6 @@
+const Prefix_ECDSA = "ecdsa";
+const Curve_SECP256K1 = "secp256k1";
+
+export enum Algorithms {
+  ECDSA_SECP256K1 = Prefix_ECDSA + ":" + Curve_SECP256K1,
+}

package/src/interfaces/blockchainevent.ts

@@ -0,0 +1,18 @@
+import { ethers } from "ethers";
+
+export interface IBlockchainEventListener {
+  name: string;
+  sources: IBlockchainEventListenerSource[];
+  options?: IBlockchainEventListenerOptions;
+}
+
+export interface IBlockchainEventListenerOptions {
+  batchSize?: number;
+  batchTimeout?: string;
+  fromBlock?: string;
+}
+
+export interface IBlockchainEventListenerSource {
+  abi: ethers.JsonFragment[];
+  address?: string;
+}

package/src/interfaces/blockindex.ts

@@ -0,0 +1,33 @@
+export interface IIndexedBlock {
+  number: number;
+  hash: string;
+  timestamp: number;
+}
+
+export interface IIndexedTransaction {
+  hash: string;
+  blockNumber: number;
+  transactionIndex: number;
+  from?: string;
+  to?: string;
+  nonce: number;
+  contractAddress?: string;
+  result?: "failure" | "success";
+  block?: IIndexedBlock;
+}
+
+export interface IIndexedEvent {
+  blockNumber: number;
+  transactionIndex: number;
+  logIndex: number;
+  transactionHash: string;
+  signature: string;
+  transaction?: IIndexedTransaction;
+  block?: IIndexedBlock;
+}
+
+export interface IEventWithData extends IIndexedEvent {
+  soliditySignature: string;
+  address: string;
+  data: any;
+}

package/src/interfaces/domains.ts

@@ -0,0 +1,10 @@
+export interface IDomain {
+  name: string;
+  registryAddress: string;
+}
+
+export interface IDomainSmartContract {
+  domainName: string;
+  domainAddress: string;
+  address: string;
+} 

package/src/interfaces/index.ts

@@ -0,0 +1,15 @@
+export * from "./algorithms";
+export * from "./blockindex";
+export * from "./blockchainevent";
+export * from "./domains";
+export * from "./keymanager";
+export * from "./logger";
+export * from "./paladin";
+export * from "./privacygroups";
+export * from "./query";
+export * from "./registry";
+export * from "./states";
+export * from "./transaction";
+export * from "./transport";
+export * from "./verifiers";
+export * from "./websocket";

package/src/interfaces/keymanager.ts

@@ -0,0 +1,35 @@
+export interface IWalletInfo {
+  name: string;
+  type: string;
+  description: string;
+}
+
+export interface IKeyMappingAndVerifier {
+  identifier: string;
+  keyHandle: string;
+  path: {
+    index: number;
+    name: string;
+  }[];
+  verifier: {
+    verifier: string;
+    type: string;
+    algorithm: string;
+  };
+  wallet: string;
+}
+
+export interface IEthAddress {
+  address: string;
+}
+
+export interface IKeyQueryEntry {
+  identifier: string;
+  keyHandle: string;
+  wallet: string;
+  verifiers: {
+    verifier: string;
+    type: string;
+    algorithm: string;
+  }[];
+}

package/src/interfaces/logger.ts

@@ -0,0 +1,8 @@
+export interface Logger {
+  log(message: any, ...optionalParams: any[]): any;
+  error(message: any, ...optionalParams: any[]): any;
+  warn(message: any, ...optionalParams: any[]): any;
+  debug?(message: any, ...optionalParams: any[]): any;
+  verbose?(message: any, ...optionalParams: any[]): any;
+  fatal?(message: any, ...optionalParams: any[]): any;
+}

package/src/interfaces/paladin.ts

@@ -0,0 +1,17 @@
+import { AxiosError, AxiosRequestConfig } from "axios";
+import { Logger } from "./logger";
+
+export interface PaladinConfig {
+  url: string;
+  requestConfig?: AxiosRequestConfig;
+  logger?: Logger;
+  onError?: PaladinErrorHandler;
+}
+
+export interface PaladinErrorHandler {
+  (method: string, err: AxiosError): void | Promise<void>;
+}
+
+export interface JsonRpcResult<T> {
+  result: T;
+}

package/src/interfaces/privacygroups.ts

@@ -0,0 +1,86 @@
+import { BigNumberish, ethers } from "ethers";
+import { HexString } from "ethers/lib.commonjs/utils/data";
+import { PublicTxOptions } from ".";
+
+export interface IPrivacyGroupInput {
+  domain: string;
+  members: string[];
+  name?: string;
+  configuration?: Record<string, string | undefined>;
+  properties?: Record<string, string | undefined>;
+  transactionOptions?: IPrivacyGroupTXOptions;
+}
+
+export interface IPrivacyGroupResume {
+  id: string;
+}
+
+export interface IPrivacyGroupTXOptions extends PublicTxOptions {
+  idempotencyKey?: string;
+}
+
+export interface IPrivacyGroup {
+  id: string;
+  domain: string;
+  created: string;
+  name: string;
+  members: string[];
+  properties: Record<string, string>;
+  configuration: Record<string, string>;
+  contractAddress?: string;
+  genesisTransaction?: string;
+  genesisSchema?: string;
+  genesisSalt?: string;
+}
+
+export interface IPrivacyGroupEVMTX {
+  from: string;
+  to?: string;
+  gas?: BigNumberish;
+  value?: BigNumberish;
+  input?: unknown;
+  function?: ethers.JsonFragment;
+  bytecode?: HexString;
+}
+
+export interface IPrivacyGroupEVMTXInput extends IPrivacyGroupEVMTX {
+  idempotencyKey?: string;
+  domain: string;
+  group: string;
+  publicTxOptions?: PublicTxOptions;
+}
+
+export interface IPrivacyGroupEVMCall extends IPrivacyGroupEVMTX {
+  domain: string;
+  group: string;
+  dataFormat?: string;
+}
+
+export interface IPrivacyGroupMessageListener {
+  name: string;
+  filters?: {
+    sequenceAbove?: number;
+    domain?: string;
+    group?: string;
+    topic?: string;
+  };
+  options?: {
+    excludeLocal?: boolean;
+  };
+}
+
+export interface IPrivacyGroupMessageInput {
+  correlationId?: string;
+  domain: string;
+  group: string;
+  topic: string;
+  data: any;
+}
+
+export interface IPrivacyGroupMessage extends IPrivacyGroupMessageInput {
+  id: string;
+  localSequence: number;
+  sent: string;
+  received: string;
+  node: string;
+}

package/src/interfaces/query.ts

@@ -0,0 +1,37 @@
+export interface IQueryOp {
+  not?: boolean;
+  caseInsensitive?: boolean;
+  field: string;
+}
+
+export interface IQueryOpSingleVal extends IQueryOp {
+  value: any;
+}
+
+export interface IQueryOpMultiVal extends IQueryOp {
+  values: any[];
+}
+
+export interface IQueryStatements {
+  or?: IQueryStatements[];
+  equal?: IQueryOpSingleVal[];
+  eq?: IQueryOpSingleVal[];
+  neq?: IQueryOpSingleVal[];
+  like?: IQueryOpSingleVal[];
+  lessThan?: IQueryOpSingleVal[];
+  lt?: IQueryOpSingleVal[];
+  lessThanOrEqual?: IQueryOpSingleVal[];
+  lte?: IQueryOpSingleVal[];
+  greaterThan?: IQueryOpSingleVal[];
+  gt?: IQueryOpSingleVal[];
+  greaterThanOrEqual?: IQueryOpSingleVal[];
+  gte?: IQueryOpSingleVal[];
+  in?: IQueryOpMultiVal[];
+  nin?: IQueryOpMultiVal[];
+  null?: IQueryOp;
+}
+
+export interface IQuery extends IQueryStatements {
+  limit?: number;
+  sort?: string[];
+}

package/src/interfaces/registry.ts

@@ -0,0 +1,27 @@
+export interface IRegistryEntry {
+  registry: string;
+  id: string;
+  name: string;
+  parentId?: string;
+  blockNumber?: number;
+  transactionIndex?: number;
+  logIndex?: number;
+  active?: boolean;
+}
+
+export interface IRegistryProperty {
+  registry: string;
+  entryId: string;
+  name: string;
+  value: string;
+  blockNumber?: number;
+  transactionIndex?: number;
+  logIndex?: number;
+  active?: boolean;
+}
+
+export interface IRegistryEntryWithProperties extends IRegistryEntry {
+  properties: { [key: string]: string };
+}
+
+export type ActiveFilter = "active" | "inactive" | "any";

package/src/interfaces/states.ts

@@ -0,0 +1,77 @@
+export interface ISchema {
+  id: string;
+  created: string;
+  domain: string;
+  type: SchemaType;
+  signature: string;
+  definition: object;
+  labels: string[];
+}
+
+export type SchemaType = "abi";
+
+export interface IStateBase {
+  id: string;
+  created: string;
+  domain: string;
+  schema: string;
+  contractAddress: string;
+  data: object;
+}
+
+export interface IStateEncoded {
+  id: string;
+  domain: string;
+  schema: string;
+  contractAddress: string;
+  data: string;
+}
+
+export interface IState extends IStateBase {
+  confirmed?: IStateConfirm;
+  spent?: IStateSpend;
+  locks?: IStateLock[];
+  nullifier?: IStateNullifier;
+}
+
+export interface IStateLabel {
+  domainName: string;
+  state: string;
+  label: string;
+  value: string;
+}
+
+export interface IStateInt64Label {
+  domainName: string;
+  state: string;
+  label: string;
+  value: number;
+}
+
+export interface IStateConfirm {
+  transaction: string;
+}
+
+export interface IStateSpend {
+  transaction: string;
+}
+
+type StateLockType = "create" | "read" | "spend";
+
+export interface IStateLock {
+  transaction: string;
+  type: StateLockType;
+}
+
+export interface IStateNullifier {
+  domain: string;
+  id: string;
+  spent?: IStateSpend;
+}
+
+export type StateStatus =
+  | "available"
+  | "confirmed"
+  | "unconfirmed"
+  | "spent"
+  | "all";