@thesingularitynetwork/darkswap-sdk 0.1.18 → 0.1.19

package/src/services/base/join.ts

@@ -1,135 +0,0 @@
-import { ethers } from 'ethers';
-import { generateJoinProof, JoinProofResult } from '../../proof/basic/joinProof';
-import { DarkSwapNote, EMPTY_NULLIFIER } from '../../types';
-import { hexlify32, isAddressEquals } from '../../utils/util';
-import { BaseContext, BaseContractService } from '../BaseService';
-import { multiGetMerklePathAndRoot } from '../merkletree';
-import { DarkSwap } from '../../darkSwap';
-import { DarkSwapError } from '../../entities';
-import { generateKeyPair } from '../../proof/keyService';
-import { createNote } from '../../proof/noteService';
-import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-
-class JoinContext extends BaseContext {
-  private _inNote1?: DarkSwapNote;
-  private _inNote2?: DarkSwapNote;
-  private _outNote?: DarkSwapNote;
-  private _proof?: JoinProofResult;
-
-  constructor(signature: string) {
-    super(signature);
-  }
-
-  set inNote1(note: DarkSwapNote | undefined) {
-    this._inNote1 = note;
-  }
-
-  get inNote1(): DarkSwapNote | undefined {
-    return this._inNote1;
-  }
-
-  set inNote2(note: DarkSwapNote | undefined) {
-    this._inNote2 = note;
-  }
-
-  get inNote2(): DarkSwapNote | undefined {
-    return this._inNote2;
-  }
-
-  set outNote(note: DarkSwapNote | undefined) {
-    this._outNote = note;
-  }
-
-  get outNote(): DarkSwapNote | undefined {
-    return this._outNote;
-  }
-
-  set proof(proof: JoinProofResult | undefined) {
-    this._proof = proof;
-  }
-
-  get proof(): JoinProofResult | undefined {
-    return this._proof;
-  }
-}
-
-export class JoinService extends BaseContractService {
-  constructor(_darkSwap: DarkSwap) {
-    super(_darkSwap);
-  }
-
-  public async prepare(
-    address: string,
-    inNote1: DarkSwapNote,
-    inNote2: DarkSwapNote,
-    signature: string
-  ): Promise<{ context: JoinContext; outNote: DarkSwapNote }> {
-    if (!isAddressEquals(inNote1.asset, inNote2.asset)) {
-      throw new DarkSwapError('inNote1 and inNote2 must have the same asset');
-    }
-
-    if (inNote1.note === inNote2.note) {
-      throw new DarkSwapError('inNote1 and inNote2 must have different note');
-    }
-
-    const [pubKey] = await generateKeyPair(signature);
-    const outNote = createNote(address, inNote1.asset, inNote1.amount + inNote2.amount, pubKey);
-    const context = new JoinContext(signature);
-    context.inNote1 = inNote1;
-    context.inNote2 = inNote2;
-    context.outNote = outNote;
-    context.address = address;
-    return { context, outNote };
-  }
-
-  private async generateProof(context: JoinContext): Promise<void> {
-    if (!context || !context.inNote1 || !context.inNote2 || !context.outNote || !context.address) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const merklePathes = await multiGetMerklePathAndRoot([context.inNote1.note, context.inNote2.note], this._darkSwap);
-    const path1 = merklePathes[0];
-    const path2 = merklePathes[1];
-
-    const proof = await generateJoinProof({
-      inNote1: context.inNote1,
-      inNote2: context.inNote2,
-      outNote: context.outNote,
-      merkleRoot: path1.root,
-      inMerklePath1: path1.path,
-      inMerkleIndex1: path1.index,
-      inMerklePath2: path2.path,
-      inMerkleIndex2: path2.index,
-      signedMessage: context.signature,
-      address: context.address,
-    });
-    context.merkleRoot = path1.root;
-    context.proof = proof;
-  }
-
-  public async execute(context: JoinContext): Promise<string> {
-    await this.generateProof(context);
-    if (!context || !context.inNote1 || !context.inNote2 || !context.outNote || !context.proof || !context.merkleRoot) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const contract = new ethers.Contract(
-      this._darkSwap.contracts.darkSwapAssetManager,
-      DarkSwapAssetManagerAbi.abi,
-      this._darkSwap.signer
-    );
-    const tx = await contract.join(
-      context.merkleRoot,
-      [
-        context.proof.inNullifier1,
-        context.proof.inNullifier2,
-        hexlify32(EMPTY_NULLIFIER)
-      ],
-      hexlify32(context.outNote.note),
-      context.proof.outNoteFooter,
-      context.proof.proof
-    );
-    await tx.wait();
-    return tx.hash;
-  }
-}

package/src/services/base/tripleJoin.ts

@@ -1,161 +0,0 @@
-import { ethers } from 'ethers';
-import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-import { DarkSwap } from '../../darkSwap';
-import { DarkSwapError } from '../../entities';
-import { generateTripleJoinProof, TripleJoinProofResult } from '../../proof/basic/tripleJoinProof';
-import { generateKeyPair } from '../../proof/keyService';
-import { createNote } from '../../proof/noteService';
-import { DarkSwapNote } from '../../types';
-import { hexlify32, isAddressEquals } from '../../utils/util';
-import { BaseContext, BaseContractService } from '../BaseService';
-import { multiGetMerklePathAndRoot } from '../merkletree';
-
-class TripleJoinContext extends BaseContext {
-  private _inNote1?: DarkSwapNote;
-  private _inNote2?: DarkSwapNote;
-  private _inNote3?: DarkSwapNote;
-  private _outNote?: DarkSwapNote;
-  private _proof?: TripleJoinProofResult;
-
-  constructor(signature: string) {
-    super(signature);
-  }
-
-  set inNote1(note: DarkSwapNote | undefined) {
-    this._inNote1 = note;
-  }
-
-  get inNote1(): DarkSwapNote | undefined {
-    return this._inNote1;
-  }
-
-  set inNote2(note: DarkSwapNote | undefined) {
-    this._inNote2 = note;
-  }
-
-  get inNote2(): DarkSwapNote | undefined {
-    return this._inNote2;
-  }
-
-  set inNote3(note: DarkSwapNote | undefined) {
-    this._inNote3 = note;
-  }
-
-  get inNote3(): DarkSwapNote | undefined {
-    return this._inNote3;
-  }
-
-
-  set outNote(note: DarkSwapNote | undefined) {
-    this._outNote = note;
-  }
-
-  get outNote(): DarkSwapNote | undefined {
-    return this._outNote;
-  }
-
-  set proof(proof: TripleJoinProofResult | undefined) {
-    this._proof = proof;
-  }
-
-  get proof(): TripleJoinProofResult | undefined {
-    return this._proof;
-  }
-}
-
-export class TripleJoinService extends BaseContractService {
-  constructor(_darkSwap: DarkSwap) {
-    super(_darkSwap);
-  }
-
-  public async prepare(
-    address: string,
-    inNote1: DarkSwapNote,
-    inNote2: DarkSwapNote,
-    inNote3: DarkSwapNote,
-    signature: string
-  ): Promise<{ context: TripleJoinContext; outNote: DarkSwapNote }> {
-    if (!isAddressEquals(inNote1.asset, inNote2.asset)) {
-      throw new DarkSwapError('inNote1 and inNote2 must have the same asset');
-    }
-
-    if (inNote1.note === inNote2.note) {
-      throw new DarkSwapError('inNote1 and inNote2 must have different note');
-    }
-
-    const [pubKey] = await generateKeyPair(signature);
-    const outNote = createNote(address, inNote1.asset, inNote1.amount + inNote2.amount + inNote3.amount, pubKey);
-    const context = new TripleJoinContext(signature);
-    context.inNote1 = inNote1;
-    context.inNote2 = inNote2;
-    context.inNote3 = inNote3;
-    context.outNote = outNote;
-    context.address = address;
-    return { context, outNote };
-  }
-
-  private async generateProof(context: TripleJoinContext): Promise<void> {
-    if (!context
-      || !context.inNote1
-      || !context.inNote2
-      || !context.inNote3
-      || !context.outNote
-      || !context.address) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const merklePathes = await multiGetMerklePathAndRoot([context.inNote1.note, context.inNote2.note, context.inNote3.note], this._darkSwap);
-    const path1 = merklePathes[0];
-    const path2 = merklePathes[1];
-    const path3 = merklePathes[2];
-
-    const proof = await generateTripleJoinProof({
-      inNote1: context.inNote1,
-      inNote2: context.inNote2,
-      inNote3: context.inNote3,
-      outNote: context.outNote,
-      merkleRoot: path1.root,
-      inMerklePath1: path1.path,
-      inMerkleIndex1: path1.index,
-      inMerklePath2: path2.path,
-      inMerkleIndex2: path2.index,
-      inMerklePath3: path3.path,
-      inMerkleIndex3: path3.index,
-      signedMessage: context.signature,
-      address: context.address,
-    });
-    context.merkleRoot = path1.root;
-    context.proof = proof;
-  }
-
-  public async execute(context: TripleJoinContext): Promise<string> {
-    await this.generateProof(context);
-    if (!context
-      || !context.inNote1
-      || !context.inNote2
-      || !context.inNote3
-      || !context.outNote
-      || !context.proof
-      || !context.merkleRoot) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const contract = new ethers.Contract(
-      this._darkSwap.contracts.darkSwapAssetManager,
-      DarkSwapAssetManagerAbi.abi,
-      this._darkSwap.signer
-    );
-    const tx = await contract.join(
-      context.merkleRoot,
-      [
-        context.proof.inNullifier1,
-        context.proof.inNullifier2,
-        context.proof.inNullifier3
-      ],
-      hexlify32(context.outNote.note),
-      context.proof.outNoteFooter,
-      context.proof.proof
-    );
-    return tx.hash;
-  }
-}

package/src/services/base/withdraw.ts

@@ -1,123 +0,0 @@
-import { ethers } from 'ethers';
-import DarkSwapAssetManagerAbi from '../../abis/DarkSwapAssetManager.json';
-import { DarkSwap } from '../../darkSwap';
-import { DarkSwapError } from '../../entities';
-import { generateWithdrawProof, WithdrawProofResult } from '../../proof/basic/withdrawProof';
-import { generateKeyPair } from '../../proof/keyService';
-import { createNote } from '../../proof/noteService';
-import { DarkSwapNote } from '../../types';
-import { BaseContext, BaseContractService } from '../BaseService';
-import { getMerklePathAndRoot } from '../merkletree';
-import { hexlify32 } from '../../utils/util';
-
-class WithdrawContext extends BaseContext {
-  private _currentBalance?: DarkSwapNote;
-  private _newBalance?: DarkSwapNote;
-  private _withdrawAmount?: bigint;
-  private _proof?: WithdrawProofResult;
-
-  constructor(signature: string) {
-    super(signature);
-  }
-
-  set currentBalance(note: DarkSwapNote | undefined) {
-    this._currentBalance = note;
-  }
-
-  get currentBalance(): DarkSwapNote | undefined {
-    return this._currentBalance;
-  }
-
-  set newBalance(note: DarkSwapNote | undefined) {
-    this._newBalance = note;
-  }
-
-  get newBalance(): DarkSwapNote | undefined {
-    return this._newBalance;
-  }
-
-  set withdrawAmount(amount: bigint | undefined) {
-    this._withdrawAmount = amount;
-  }
-
-  get withdrawAmount(): bigint | undefined {
-    return this._withdrawAmount;
-  }
-
-  set proof(proof: WithdrawProofResult | undefined) {
-    this._proof = proof;
-  }
-
-  get proof(): WithdrawProofResult | undefined {
-    return this._proof;
-  }
-}
-
-export class WithdrawService extends BaseContractService {
-  constructor(_darkSwap: DarkSwap) {
-    super(_darkSwap);
-  }
-
-  public async prepare(
-    address: string,
-    currentBalance: DarkSwapNote,
-    withdrawAmount: bigint,
-    signature: string
-  ): Promise<{ context: WithdrawContext; newBalanceNote: DarkSwapNote }> {
-    const [pubKey] = await generateKeyPair(signature);
-    const newBalanceNote = createNote(address, currentBalance.asset, currentBalance.amount - withdrawAmount, pubKey);
-
-    const context = new WithdrawContext(signature);
-    context.currentBalance = currentBalance;
-    context.newBalance = newBalanceNote;
-    context.withdrawAmount = withdrawAmount;
-    context.address = address;
-    return { context, newBalanceNote };
-  }
-
-  private async generateProof(context: WithdrawContext): Promise<void> {
-    if (!context || !context.currentBalance || !context.newBalance || !context.withdrawAmount || !context.address) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const path = await getMerklePathAndRoot(context.currentBalance.note, this._darkSwap);
-    context.merkleRoot = path.root;
-
-    const proof = await generateWithdrawProof({
-      oldBalance: context.currentBalance,
-      newBalance: context.newBalance,
-      address: context.address,
-      merkleRoot: path.root,
-      merklePath: path.path,
-      merkleIndex: path.index,
-      signedMessage: context.signature,
-    });
-    context.proof = proof;
-  }
-
-  public async execute(context: WithdrawContext): Promise<string> {
-    await this.generateProof(context);
-
-    if (!context || !context.currentBalance || !context.newBalance || !context.proof || !context.merkleRoot) {
-      throw new DarkSwapError('Invalid context');
-    }
-
-    const contract = new ethers.Contract(
-      this._darkSwap.contracts.darkSwapAssetManager,
-      DarkSwapAssetManagerAbi.abi,
-      this._darkSwap.signer
-    );
-
-    const tx = await contract.withdraw(
-      context.merkleRoot,
-      context.currentBalance.asset,
-      context.withdrawAmount,
-      context.proof.oldBalanceNullifier,
-      hexlify32(context.newBalance.note),
-      context.proof.newBalanceFooter,
-      context.proof.proof
-    );
-    await tx.wait();
-    return tx.hash;
-  }
-}

package/src/services/feeRatioService.ts

@@ -1,13 +0,0 @@
-import { ethers } from 'ethers';
-import DarkSwapFeeAssetManagerAbi from '../abis/DarkSwapFeeAssetManager.json';
-import { DarkSwap } from '../darkSwap';
-
-function getContract(address: string, darkSwap: DarkSwap) {
-  const provider = darkSwap.provider;
-  return new ethers.Contract(address, DarkSwapFeeAssetManagerAbi.abi, provider);
-}
-
-export async function getFeeRatio(wallet: string, darkSwap: DarkSwap) {
-  const contract = getContract(darkSwap.contracts.darkSwapFeeAssetManager, darkSwap);
-  return await contract.getServiceFeePercentage(wallet);
-}

package/src/services/index.ts

@@ -1,7 +0,0 @@
-export * from './noteService';
-export * from './base';
-export * from './pro';
-export * from './retail';
-export * from './merkletree';
-export * from './feeRatioService';
-export * from './agent';

package/src/services/merkletree.ts

@@ -1,46 +0,0 @@
-import { ethers } from 'ethers';
-import MerkleAbi from '../abis/MerkleTreeOperator.json';
-import { hexlify32 } from '../utils/util';
-import { DarkSwap } from '../darkSwap';
-
-
-export interface MerklePath {
-  noteCommitment: bigint;
-  path: string[];
-  index: number[];
-  root: string;
-}
-
-export const EMPTY_PATH: MerklePath = {
-  noteCommitment: 0n,
-  path: Array(32).fill('0x0000000000000000000000000000000000000000000000000000000000000000'),
-  index: Array(32).fill(0),
-  root: '0x0000000000000000000000000000000000000000000000000000000000000000'
-}
-
-function getContract(address: string, darkSwap: DarkSwap) {
-  const provider = darkSwap.provider;
-  return new ethers.Contract(address, MerkleAbi.abi, provider);
-}
-
-export async function getMerklePathAndRoot(note: bigint, darkSwap: DarkSwap): Promise<MerklePath> {
-  const result = await multiGetMerklePathAndRoot([note], darkSwap);
-  return result[0];
-}
-
-export async function multiGetMerklePathAndRoot(notes: bigint[], darkSwap: DarkSwap): Promise<MerklePath[]> {
-  const contract = getContract(darkSwap.contracts.merkleTreeOperator, darkSwap);
-
-  const [root, paths, indexes] = await contract.getMultiMerklePaths(notes.map(note => hexlify32(note)));
-  const results: MerklePath[] = [];
-  for (let i = 0; i < notes.length; i++) {
-    results.push({
-      noteCommitment: notes[i],
-      path: paths[i],
-      index: indexes[i].map((x: boolean) => (x ? 1 : 0)),
-      root
-    });
-  }
-
-  return results;
-}

package/src/services/noteService.ts

@@ -1,75 +0,0 @@
-import { hexlify32 } from '../utils/util';
-import { ethers } from 'ethers';
-import MerkleAbi from '../abis/MerkleTreeOperator.json';
-import { NoteOnChainStatus } from '../entities';
-import { DarkSwap } from '../darkSwap';
-import { DarkSwapNote } from '../types';
-import { calcNullifier } from '../proof/noteService';
-import { generateKeyPair } from '../proof/keyService';
-import { Fr } from '../aztec/fields/fields';
-
-function getContract(address: string, darkSwap: DarkSwap) {
-  const provider = darkSwap.provider;
-  return new ethers.Contract(address, MerkleAbi.abi, provider);
-}
-
-async function getNoteOnChainStatus(darkSwap: DarkSwap, note: string, nullifier: string) {
-  const contract = getContract(darkSwap.contracts.merkleTreeOperator, darkSwap);
-  const isCreated = (await contract.noteCommitmentsCreated(note)) as boolean;
-  if (!isCreated) {
-    return NoteOnChainStatus.UNKNOWN;
-  }
-  const isSpent = (await contract.nullifiersUsed(nullifier)) as boolean;
-  if (isSpent) {
-    return NoteOnChainStatus.SPENT;
-  }
-  const isLocked = (await contract.nullifiersLocked(nullifier)) as boolean;
-  if (isLocked) {
-    return NoteOnChainStatus.LOCKED;
-  }
-  return NoteOnChainStatus.ACTIVE;
-}
-
-export async function getNoteOnChainStatusByPublicKey(
-  darkSwap: DarkSwap,
-  note: DarkSwapNote,
-  publicKey: [Fr, Fr]
-): Promise<NoteOnChainStatus> {
-  const nullifier = calcNullifier(note.rho, publicKey);
-  const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-  return onChainStatus;
-}
-
-export async function getNoteOnChainStatusBySignature(
-  darkSwap: DarkSwap,
-  note: DarkSwapNote,
-  signature: string
-): Promise<NoteOnChainStatus> {
-  const [publicKey] = await generateKeyPair(signature);
-  const nullifier = calcNullifier(note.rho, publicKey);
-  const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-  return onChainStatus;
-}
-
-export async function isNoteActive(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]): Promise<boolean> {
-  const nullifier = calcNullifier(note.rho, publicKey);
-  const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-  return onChainStatus === NoteOnChainStatus.ACTIVE;
-}
-
-export async function isNoteSpent(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]) {
-  const nullifier = calcNullifier(note.rho, publicKey);
-  const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-  return onChainStatus === NoteOnChainStatus.SPENT;
-}
-
-export async function isNoteValid(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]) {
-  const nullifier = calcNullifier(note.rho, publicKey);
-  const onChainStatus = await getNoteOnChainStatus(darkSwap, hexlify32(note.note), hexlify32(nullifier));
-  return onChainStatus === NoteOnChainStatus.ACTIVE;
-}
-
-export async function getNullifierBySignature(note: DarkSwapNote, signature: string): Promise<string> {
-  const [publicKey] = await generateKeyPair(signature);
-  return hexlify32(calcNullifier(note.rho, publicKey));
-}