@lfdecentralizedtrust/paladin-sdk 0.13.0-rc.1

package/src/domains/noto.ts

@@ -0,0 +1,420 @@
+import { ethers } from "ethers";
+import { IStateEncoded, TransactionType } from "../interfaces";
+import PaladinClient from "../paladin";
+import { TransactionFuture } from "../transaction";
+import { PaladinVerifier } from "../verifier";
+import * as notoJSON from "./abis/INoto.json";
+import * as notoPrivateJSON from "./abis/INotoPrivate.json";
+
+export const notoConstructorABI = (
+  withHooks: boolean
+): ethers.JsonFragment => ({
+  type: "constructor",
+  inputs: [
+    { name: "name", type: "string" },
+    { name: "symbol", type: "string" },
+    { name: "notary", type: "string" },
+    { name: "notaryMode", type: "string" },
+    {
+      name: "options",
+      type: "tuple",
+      components: [
+        ...(withHooks
+          ? [
+              {
+                name: "hooks",
+                type: "tuple",
+                components: [
+                  {
+                    name: "privateGroup",
+                    type: "tuple",
+                    components: [
+                      { name: "salt", type: "bytes32" },
+                      { name: "members", type: "string[]" },
+                    ],
+                  },
+                  { name: "publicAddress", type: "address" },
+                  { name: "privateAddress", type: "address" },
+                ],
+              },
+            ]
+          : [
+              {
+                name: "basic",
+                type: "tuple",
+                components: [
+                  { name: "restrictMint", type: "bool" },
+                  { name: "allowBurn", type: "bool" },
+                  { name: "allowLock", type: "bool" },
+                ],
+              },
+            ]),
+      ],
+    },
+  ],
+});
+
+export interface IGroupInfo {
+  salt: string;
+  members: string[];
+}
+
+export interface NotoConstructorParams {
+  // Added in NotoFactory V1 (will be ignored in V0)
+  name?: string;
+
+  // Added in NotoFactory V1 (will be ignored in V0)
+  symbol?: string;
+
+  notary: PaladinVerifier;
+  notaryMode: "basic" | "hooks";
+  options?: {
+    basic?: {
+      restrictMint: boolean;
+      allowBurn: boolean;
+      allowLock: boolean;
+    };
+    hooks?: {
+      publicAddress: string;
+      privateGroup?: IGroupInfo;
+      privateAddress?: string;
+    };
+  };
+}
+
+export interface NotoMintParams {
+  to: PaladinVerifier;
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoBurnParams {
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoBurnFromParams {
+  from: PaladinVerifier;
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoTransferParams {
+  to: PaladinVerifier;
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoTransferFromParams {
+  from: PaladinVerifier;
+  to: PaladinVerifier;
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoLockParams {
+  amount: string | number;
+  data: string;
+}
+
+export interface NotoUnlockParams {
+  lockId: string;
+  from: PaladinVerifier;
+  recipients: UnlockRecipient[];
+  data: string;
+}
+
+export interface UnlockRecipient {
+  to: PaladinVerifier;
+  amount: string | number;
+}
+
+export interface NotoDelegateLockParams {
+  lockId: string;
+  unlock: NotoUnlockPublicParams;
+  delegate: string;
+  data: string;
+}
+
+export interface NotoUnlockPublicParams {
+  txId: string;
+  lockedInputs: string[];
+  lockedOutputs: string[];
+  outputs: string[];
+  signature: string;
+  data: string;
+}
+
+export interface NotoBalanceOfParams {
+  account: string;
+}
+
+export interface NotoBalanceOfResult {
+  totalBalance: string;
+  totalStates: string;
+  overflow: boolean;
+}
+
+// Represents an in-flight Noto deployment
+export class NotoFuture extends TransactionFuture {
+  async waitForDeploy(waitMs?: number) {
+    const receipt = await this.waitForReceipt(waitMs);
+    return receipt?.contractAddress
+      ? new NotoInstance(this.paladin, receipt.contractAddress)
+      : undefined;
+  }
+}
+
+export class NotoFactory {
+  constructor(private paladin: PaladinClient, public readonly domain: string) {}
+
+  using(paladin: PaladinClient) {
+    return new NotoFactory(paladin, this.domain);
+  }
+
+  newNoto(from: PaladinVerifier, data: NotoConstructorParams) {
+    return new NotoFuture(
+      this.paladin,
+      this.paladin.ptx.sendTransaction({
+        type: TransactionType.PRIVATE,
+        domain: this.domain,
+        abi: [notoConstructorABI(!!data.options?.hooks)],
+        function: "",
+        from: from.lookup,
+        data: {
+          ...data,
+          name: data.name ?? "",
+          symbol: data.symbol ?? "",
+          notary: data.notary.lookup,
+          options: {
+            basic: {
+              restrictMint: true,
+              allowBurn: true,
+              allowLock: true,
+              ...data.options?.basic,
+            },
+            ...data.options,
+          },
+        },
+      })
+    );
+  }
+}
+
+export class NotoInstance {
+  constructor(
+    private paladin: PaladinClient,
+    public readonly address: string
+  ) {}
+
+  using(paladin: PaladinClient) {
+    return new NotoInstance(paladin, this.address);
+  }
+
+  mint(from: PaladinVerifier, data: NotoMintParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "mint",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          to: data.to.lookup,
+        },
+      })
+    );
+  }
+
+  transfer(from: PaladinVerifier, data: NotoTransferParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "transfer",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          to: data.to.lookup,
+        },
+      })
+    );
+  }
+
+  transferFrom(from: PaladinVerifier, data: NotoTransferFromParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "transferFrom",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          from: data.from.lookup,
+          to: data.to.lookup,
+        },
+      })
+    );
+  }
+
+  prepareTransfer(from: PaladinVerifier, data: NotoTransferParams) {
+    return this.paladin.prepareTransaction({
+      type: TransactionType.PRIVATE,
+      abi: notoPrivateJSON.abi,
+      function: "transfer",
+      to: this.address,
+      from: from.lookup,
+      data: {
+        ...data,
+        to: data.to.lookup,
+      },
+    });
+  }
+
+  burn(from: PaladinVerifier, data: NotoBurnParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "burn",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  burnFrom(from: PaladinVerifier, data: NotoBurnFromParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "burnFrom",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          from: data.from.lookup,
+        }
+      })
+    );
+  }
+
+  lock(from: PaladinVerifier, data: NotoLockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "lock",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  unlock(from: PaladinVerifier, data: NotoUnlockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "unlock",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          from: data.from.lookup,
+          recipients: data.recipients.map((recipient) => ({
+            to: recipient.to.lookup,
+            amount: recipient.amount,
+          })),
+        },
+      })
+    );
+  }
+
+  unlockAsDelegate(from: PaladinVerifier, data: NotoUnlockPublicParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PUBLIC,
+        abi: notoJSON.abi,
+        function: "unlock",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  prepareUnlock(from: PaladinVerifier, data: NotoUnlockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "prepareUnlock",
+        to: this.address,
+        from: from.lookup,
+        data: {
+          ...data,
+          from: data.from.lookup,
+          recipients: data.recipients.map((recipient) => ({
+            to: recipient.to.lookup,
+            amount: recipient.amount,
+          })),
+        },
+      })
+    );
+  }
+
+  delegateLock(from: PaladinVerifier, data: NotoDelegateLockParams) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PRIVATE,
+        abi: notoPrivateJSON.abi,
+        function: "delegateLock",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+
+  encodeUnlock(data: NotoUnlockPublicParams) {
+    return new ethers.Interface(notoJSON.abi).encodeFunctionData("unlock", [
+      data.txId,
+      data.lockedInputs,
+      data.lockedOutputs,
+      data.outputs,
+      data.signature,
+      data.data,
+    ]);
+  }
+
+  balanceOf(
+    from: PaladinVerifier,
+    data: NotoBalanceOfParams
+  ): Promise<NotoBalanceOfResult> {
+    return this.paladin.call({
+      type: TransactionType.PRIVATE,
+      domain: "noto",
+      abi: notoPrivateJSON.abi,
+      function: "balanceOf",
+      to: this.address,
+      from: from.lookup,
+      data,
+    });
+  }
+}

package/src/domains/pente.ts

@@ -0,0 +1,287 @@
+import { ethers } from "ethers";
+import { TransactionType } from "../interfaces";
+import {
+  IPrivacyGroup,
+  IPrivacyGroupEVMCall,
+  IPrivacyGroupEVMTXInput,
+  IPrivacyGroupResume,
+} from "../interfaces/privacygroups";
+import PaladinClient from "../paladin";
+import { TransactionFuture } from "../transaction";
+import { PaladinVerifier } from "../verifier";
+import * as penteJSON from "./abis/PentePrivacyGroup.json";
+
+export interface PenteGroupTransactionInput {
+  from: string;
+  methodAbi: ethers.JsonFragment;
+  to: string;
+  data: {
+    [key: string]: any;
+  };
+}
+
+export interface PenteContractTransactionInput {
+  from: string;
+  function: string;
+  data?: {
+    [key: string]: any;
+  };
+}
+
+export interface PenteDeploy {
+  abi: ReadonlyArray<ethers.JsonFragment>;
+  bytecode: string;
+  from: string;
+  inputs?: any;
+}
+
+export interface PentePrivacyGroupParams {
+  name?: string;
+  members: (string | PaladinVerifier)[];
+  salt?: string;
+  evmVersion?: string;
+  endorsementType?: string;
+  externalCallsEnabled?: boolean;
+  additionalProperties?: {
+    [x: string]: unknown;
+  };
+}
+
+export interface PenteApproveTransitionParams {
+  txId: string;
+  delegate: string;
+  transitionHash: string;
+  signatures: string[];
+}
+
+// Represents an in-flight Pente privacy group deployment
+export class PentePrivacyGroupFuture {
+  public tx: Promise<TransactionFuture | undefined>;
+
+  constructor(
+    private paladin: PaladinClient,
+    private group: IPrivacyGroup | Promise<IPrivacyGroup>
+  ) {
+    this.tx = Promise.resolve(group).then((group) =>
+      group.genesisTransaction
+        ? new TransactionFuture(paladin, group.genesisTransaction)
+        : undefined
+    );
+  }
+
+  async waitForReceipt(waitMs?: number, full = false) {
+    const tx = await this.tx;
+    return tx?.waitForReceipt(waitMs, full);
+  }
+
+  async waitForDeploy(waitMs?: number) {
+    const group = await this.group;
+    const receipt = await this.waitForReceipt(waitMs);
+    group.contractAddress = receipt?.contractAddress;
+    return group.contractAddress
+      ? new PentePrivacyGroup(this.paladin, group)
+      : undefined;
+  }
+}
+
+export class PenteFactory {
+  constructor(private paladin: PaladinClient, public readonly domain: string) {}
+
+  using(paladin: PaladinClient) {
+    return new PenteFactory(paladin, this.domain);
+  }
+
+  newPrivacyGroup(input: PentePrivacyGroupParams) {
+    return new PentePrivacyGroupFuture(
+      this.paladin,
+      this.paladin.pgroup.createGroup({
+        domain: this.domain,
+        name: input.name,
+        members: input.members.map((m) => m.toString()),
+        configuration: {
+          evmVersion: input.evmVersion,
+          endorsementType: input.endorsementType,
+          externalCallsEnabled:
+            input.externalCallsEnabled === true
+              ? "true"
+              : input.externalCallsEnabled === false
+              ? "false"
+              : undefined,
+        },
+      })
+    );
+  }
+
+  async resumePrivacyGroup(input: IPrivacyGroupResume) {
+    const existingGroup = await this.paladin.getPrivacyGroupById(
+      this.domain,
+      input.id
+    );
+    return existingGroup?.contractAddress
+      ? new PentePrivacyGroup(this.paladin, existingGroup)
+      : undefined;
+  }
+}
+
+export class PentePrivacyGroup {
+  public readonly address: string;
+  public readonly salt: string;
+  public readonly members: string[];
+
+  constructor(
+    private paladin: PaladinClient,
+    public readonly group: IPrivacyGroup
+  ) {
+    if (group.contractAddress === undefined) {
+      throw new Error(
+        `Supplied group '${group.id}' is missing a contract address. Check transaction ${group.genesisTransaction}`
+      );
+    }
+    this.address = group.contractAddress;
+    this.salt = group.id; // when bypassing privacy group helper functionality, and directly building Pente private transactions
+    this.members = group.members;
+  }
+
+  using(paladin: PaladinClient) {
+    return new PentePrivacyGroup(paladin, this.group);
+  }
+
+  deploy(params: PenteDeploy, txOptions?: Partial<IPrivacyGroupEVMTXInput>) {
+    // Find the constructor in the ABI
+    const constructor: ethers.JsonFragment = params.abi.find(
+      (entry) => entry.type === "constructor"
+    ) || { type: "constructor", inputs: [] };
+
+    const transaction: IPrivacyGroupEVMTXInput = {
+      ...txOptions,
+      domain: this.group.domain,
+      group: this.group.id,
+      from: params.from,
+      input: params.inputs,
+      bytecode: params.bytecode,
+      function: constructor,
+    };
+
+    return new PentePrivateDeployFuture(
+      this.paladin,
+      this.paladin.sendPrivacyGroupTransaction(transaction)
+    );
+  }
+
+  // sendTransaction functions in the contract (write)
+  sendTransaction(
+    transaction: PenteGroupTransactionInput,
+    txOptions?: Partial<IPrivacyGroupEVMTXInput>
+  ) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendPrivacyGroupTransaction({
+        ...txOptions,
+        domain: this.group.domain,
+        group: this.group.id,
+        from: transaction.from,
+        to: transaction.to,
+        input: transaction.data,
+        function: transaction.methodAbi,
+      })
+    );
+  }
+
+  // call functions in the contract (read-only)
+  async call(
+    transaction: PenteGroupTransactionInput,
+    txOptions?: Partial<IPrivacyGroupEVMCall>
+  ) {
+    return this.paladin.callPrivacyGroup({
+      ...txOptions,
+      domain: this.group.domain,
+      group: this.group.id,
+      from: transaction.from || "sdk.default",
+      to: transaction.to,
+      input: transaction.data,
+      function: transaction.methodAbi,
+    });
+  }
+
+  approveTransition(
+    from: PaladinVerifier,
+    data: PenteApproveTransitionParams
+  ) {
+    return new TransactionFuture(
+      this.paladin,
+      this.paladin.sendTransaction({
+        type: TransactionType.PUBLIC,
+        abi: penteJSON.abi,
+        function: "approveTransition",
+        to: this.address,
+        from: from.lookup,
+        data,
+      })
+    );
+  }
+}
+
+// Represents an in-flight contract deployment within a privacy group
+export class PentePrivateDeployFuture extends TransactionFuture {
+  async waitForDeploy(waitMs?: number) {
+    const receipt = await this.waitForReceipt(waitMs, true);
+    return receipt?.domainReceipt !== undefined &&
+      "receipt" in receipt.domainReceipt
+      ? receipt.domainReceipt.receipt.contractAddress
+      : undefined;
+  }
+}
+
+export abstract class PentePrivateContract<ConstructorParams> {
+  constructor(
+    protected evm: PentePrivacyGroup,
+    protected abi: ReadonlyArray<ethers.JsonFragment>,
+    public readonly address: string
+  ) {}
+
+  abstract using(
+    paladin: PaladinClient
+  ): PentePrivateContract<ConstructorParams>;
+
+  sendTransaction(
+    transaction: PenteContractTransactionInput,
+    txOptions?: Partial<IPrivacyGroupEVMTXInput>
+  ) {
+    const method = this.abi.find(
+      (entry) => entry.name === transaction.function
+    );
+    if (method === undefined) {
+      throw new Error(`Method '${transaction.function}' not found`);
+    }
+    return this.evm.sendTransaction(
+      {
+        from: transaction.from,
+        to: this.address,
+        methodAbi: method,
+        data: transaction.data ?? [],
+      },
+      txOptions
+    );
+  }
+
+  call(
+    transaction: PenteContractTransactionInput,
+    txOptions?: Partial<IPrivacyGroupEVMCall>
+  ) {
+    const method = this.abi.find(
+      (entry) => entry.name === transaction.function
+    );
+    if (method === undefined) {
+      throw new Error(`Method '${transaction.function}' not found`);
+    }
+    return this.evm.call(
+      {
+        from: transaction.from,
+        to: this.address,
+        methodAbi: method,
+        data: transaction.data ?? [],
+      },
+      txOptions
+    );
+  }
+}