@thesingularitynetwork/darkswap-sdk 0.1.0 → 0.1.1

package/dist/src/config/chain.d.ts

@@ -0,0 +1,9 @@
+export declare enum ChainId {
+    HARDHAT = 31337,
+    HARDHAT_ARBITRUM = 31338,
+    HARDHAT_BASE = 31339,
+    MAINNET = 1,
+    SEPOLIA = 11155111,
+    ARBITRUM_ONE = 42161,
+    BASE = 8453
+}

package/dist/src/config/config.d.ts

@@ -0,0 +1,4 @@
+export declare const legacyTokenConfig: {
+    [chainId: number]: string[];
+};
+export declare const FEE_RATIO = 300n;

package/dist/src/config/contractConfig.d.ts

@@ -0,0 +1,12 @@
+export type ContractConfiguartion = {
+    priceOracle: string;
+    ethAddress: string;
+    nativeWrapper: string;
+    merkleTreeOperator: string;
+    darkSwapAssetManager: string;
+    darkSwapFeeAssetManager: string;
+    drakpoolSubgraphUrl: string;
+};
+export declare const contractConfig: {
+    [chainId: number]: ContractConfiguartion;
+};

package/dist/src/darkSwap.d.ts

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+import { ContractConfiguartion } from './config/contractConfig';
+export declare class DarkSwap {
+    signer: ethers.Signer;
+    provider: ethers.Provider;
+    chainId: number;
+    contracts: ContractConfiguartion;
+    constructor(signer: ethers.Signer, chainId: number, contracts?: ContractConfiguartion);
+}

package/dist/src/entities/error.d.ts

@@ -0,0 +1,3 @@
+export declare class DarkSwapError extends Error {
+    constructor(message: string);
+}

package/dist/src/entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error';
+export * from './token';
+export * from './types';

package/dist/src/entities/token.d.ts

@@ -0,0 +1,8 @@
+export type SimpleToken = {
+    address: string;
+    decimals: number;
+};
+export type Token = SimpleToken & {
+    symbol: string;
+    name: string;
+};

package/dist/src/entities/types.d.ts

@@ -0,0 +1,6 @@
+export declare enum NoteOnChainStatus {
+    ACTIVE = "ACTIVE",
+    SPENT = "SPENT",
+    LOCKED = "LOCKED",
+    UNKNOWN = "UNKNOWN"
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './services';
+export * from './entities';
+export * from './darkSwap';
+export * from './utils/util';

package/dist/src/proof/baseProofService.d.ts

@@ -0,0 +1,6 @@
+import { Fr } from "@aztec/foundation/fields";
+export declare function generateProof(circuit: any, inputs: any): Promise<{
+    proof: string;
+    verifyInputs: string[];
+}>;
+export declare function signMessage(message: string, fuzkPriKey: Fr): Promise<Buffer<ArrayBufferLike>>;

package/dist/src/proof/basic/depositProof.d.ts

@@ -0,0 +1,13 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote } from "../../types";
+export type DepositProofParam = BaseProofParam & {
+    merkleRoot: string;
+    merkleIndex: number[];
+    merklePath: string[];
+    oldBalanceNote: DarkSwapNote;
+    newBalanceNote: DarkSwapNote;
+};
+export type DepositProofResult = BaseProofResult & {
+    oldBalanceNullifier: string;
+    newBalanceFooter: string;
+};
+export declare function generateDepositProof(param: DepositProofParam): Promise<DepositProofResult>;

package/dist/src/proof/basic/joinProof.d.ts

@@ -0,0 +1,17 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote } from "../../types";
+export type JoinProofParam = BaseProofParam & {
+    merkleRoot: string;
+    inMerkleIndex1: number[];
+    inMerkleIndex2: number[];
+    inMerklePath1: string[];
+    inMerklePath2: string[];
+    inNote1: DarkSwapNote;
+    inNote2: DarkSwapNote;
+    outNote: DarkSwapNote;
+};
+export type JoinProofResult = BaseProofResult & {
+    inNullifier1: string;
+    inNullifier2: string;
+    outNoteFooter: string;
+};
+export declare function generateJoinProof(param: JoinProofParam): Promise<JoinProofResult>;

package/dist/src/proof/basic/tripleJoinProof.d.ts

@@ -0,0 +1,21 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote } from "../../types";
+export type TripleJoinProofParam = BaseProofParam & {
+    merkleRoot: string;
+    inMerkleIndex1: number[];
+    inMerkleIndex2: number[];
+    inMerkleIndex3: number[];
+    inMerklePath1: string[];
+    inMerklePath2: string[];
+    inMerklePath3: string[];
+    inNote1: DarkSwapNote;
+    inNote2: DarkSwapNote;
+    inNote3: DarkSwapNote;
+    outNote: DarkSwapNote;
+};
+export type TripleJoinProofResult = BaseProofResult & {
+    inNullifier1: string;
+    inNullifier2: string;
+    inNullifier3: string;
+    outNoteFooter: string;
+};
+export declare function generateTripleJoinProof(param: TripleJoinProofParam): Promise<TripleJoinProofResult>;

package/dist/src/proof/basic/withdrawProof.d.ts

@@ -0,0 +1,13 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote } from "../../types";
+export type WithdrawProofParam = BaseProofParam & {
+    merkleRoot: string;
+    merkleIndex: number[];
+    merklePath: string[];
+    oldBalance: DarkSwapNote;
+    newBalance: DarkSwapNote;
+};
+export type WithdrawProofResult = BaseProofResult & {
+    oldBalanceNullifier: string;
+    newBalanceFooter: string;
+};
+export declare function generateWithdrawProof(param: WithdrawProofParam): Promise<WithdrawProofResult>;

package/dist/src/proof/keyService.d.ts

@@ -0,0 +1,2 @@
+import { Fr } from "@aztec/foundation/fields";
+export declare function generateKeyPair(signature: string): Promise<[[Fr, Fr], Fr]>;

package/dist/src/proof/noteService.d.ts

@@ -0,0 +1,9 @@
+import { Fr } from "@aztec/foundation/fields";
+import { DarkSwapNote, DarkSwapNoteExt, DarkSwapOrderNote } from "../types.js";
+export declare const DOMAIN_NOTE = 2n;
+export declare const DOMAIN_ORDER_NOTE = 3n;
+export declare const EMPTY_NOTE: DarkSwapNote;
+export declare function createNote(address: string, asset: string, amount: bigint, fuzkPubKey: [Fr, Fr]): DarkSwapNoteExt;
+export declare function getNoteFooter(rho: bigint, publicKey: [Fr, Fr]): bigint;
+export declare function calcNullifier(rho: bigint, fuzkPubKey: [Fr, Fr]): bigint;
+export declare function createOrderNoteExt(address: string, asset: string, amount: bigint, feeRatio: bigint, fuzkPubKey: [Fr, Fr]): DarkSwapOrderNote;

package/dist/src/proof/pro/orders/cancelOrderProof.d.ts

@@ -0,0 +1,15 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote, DarkSwapOrderNote } from "../../../types";
+export type ProCancelOrderProofParam = BaseProofParam & {
+    merkleRoot: string;
+    merkleIndex: number[];
+    merklePath: string[];
+    orderNote: DarkSwapOrderNote;
+    oldBalanceNote: DarkSwapNote;
+    newBalanceNote: DarkSwapNote;
+};
+export type ProCancelOrderProofResult = BaseProofResult & {
+    orderNullifier: string;
+    oldBalanceNullifier: string;
+    newBalanceNoteFooter: string;
+};
+export declare function generateProCancelOrderProof(param: ProCancelOrderProofParam): Promise<ProCancelOrderProofResult>;

package/dist/src/proof/pro/orders/createOrderProof.d.ts

@@ -0,0 +1,16 @@
+import { BaseProofParam, BaseProofResult, DarkSwapNote, DarkSwapOrderNote } from "../../../types";
+export type ProCreateOrderProofParam = BaseProofParam & {
+    merkleRoot: string;
+    merkleIndex: number[];
+    merklePath: string[];
+    oldBalanceNote: DarkSwapNote;
+    newBalanceNote: DarkSwapNote;
+    orderNote: DarkSwapOrderNote;
+    inNote: DarkSwapNote;
+};
+export type ProCreateOrderProofResult = BaseProofResult & {
+    oldBalanceNullifier: string;
+    newBalanceFooter: string;
+    orderNoteFooter: string;
+};
+export declare function generateProCreateOrderProof(param: ProCreateOrderProofParam): Promise<ProCreateOrderProofResult>;

package/dist/src/proof/pro/orders/swapProof.d.ts

@@ -0,0 +1,23 @@
+import { BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from "../../../types";
+export type ProSwapProofParam = {
+    merkleRoot: string;
+    aliceMerkleIndex: number[];
+    aliceMerklePath: string[];
+    aliceAddress: string;
+    aliceOrderNote: DarkSwapOrderNote;
+    aliceInNote: DarkSwapNote;
+    aliceChangeNote: DarkSwapNote;
+    aliceSignedMessage: string;
+    bobMerkleIndex: number[];
+    bobMerklePath: string[];
+    bobAddress: string;
+    bobMessage: DarkSwapMessage;
+};
+export type ProSwapProofResult = BaseProofResult & {
+    aliceOutNullifier: string;
+    aliceInNoteFooter: string;
+    aliceChangeNoteFooter: string;
+    bobOutNullifier: string;
+    bobInNoteFooter: string;
+};
+export declare function generateProSwapProof(param: ProSwapProofParam): Promise<ProSwapProofResult>;

package/dist/src/proof/retail/cancelOrderProof.d.ts

@@ -0,0 +1,11 @@
+import { BaseProofParam, BaseProofResult, DarkSwapOrderNote } from "../../types";
+export type RetailCancelOrderProofParam = BaseProofParam & {
+    merkleRoot: string;
+    merkleIndex: number[];
+    merklePath: string[];
+    orderNote: DarkSwapOrderNote;
+};
+export type RetailCancelOrderProofResult = BaseProofResult & {
+    nullifier: string;
+};
+export declare function generateRetailCancelOrderProof(param: RetailCancelOrderProofParam): Promise<RetailCancelOrderProofResult>;

package/dist/src/proof/retail/depositOrderProof.d.ts

@@ -0,0 +1,14 @@
+import { BaseProofParam, BaseProofResult, DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from "../../types";
+import { Fr } from "@aztec/foundation/fields";
+export type RetailCreateOrderProofParam = BaseProofParam & {
+    depositNote: DarkSwapOrderNote;
+    swapInNote: DarkSwapNote;
+    feeAmount: bigint;
+};
+export type RetailCreateOrderProofResult = BaseProofResult & {
+    depositNullifier: string;
+    depositFooter: string;
+    swapInNoteFooter: string;
+};
+export declare function generateRetailSwapMessage(address: string, orderNote: DarkSwapOrderNote, swapInNote: DarkSwapNote, pubKey: [Fr, Fr], privKey: Fr): Promise<DarkSwapMessage>;
+export declare function generateRetailCreateOrderProof(param: RetailCreateOrderProofParam): Promise<RetailCreateOrderProofResult>;

package/dist/src/proof/retail/swapProof.d.ts

@@ -0,0 +1,19 @@
+import { BaseProofResult, DarkSwapMessage } from "../../types";
+export type RetailSwapProofParam = {
+    merkleRoot: string;
+    aliceMerkleIndex: number[];
+    aliceMerklePath: string[];
+    aliceAddress: string;
+    aliceMessage: DarkSwapMessage;
+    bobMerkleIndex: number[];
+    bobMerklePath: string[];
+    bobAddress: string;
+    bobMessage: DarkSwapMessage;
+};
+export type RetailSwapProofResult = BaseProofResult & {
+    aliceOrderNullifier: string;
+    aliceInNoteFooter: string;
+    bobOrderNullifier: string;
+    bobInNoteFooter: string;
+};
+export declare function generateRetailSwapProof(param: RetailSwapProofParam): Promise<RetailSwapProofResult>;

package/dist/src/services/BaseService.d.ts

@@ -0,0 +1,19 @@
+import { DarkSwap } from '../darkSwap';
+export declare class BaseContext {
+    private _address?;
+    private _signature;
+    private _merkleRoot?;
+    private _tx?;
+    constructor(signature: string);
+    set address(address: string | undefined);
+    get address(): string | undefined;
+    get signature(): string;
+    set merkleRoot(merkleRoot: string | undefined);
+    get merkleRoot(): string | undefined;
+    set tx(tx: string | undefined);
+    get tx(): string | undefined;
+}
+export declare abstract class BaseContractService {
+    protected _darkSwap: DarkSwap;
+    constructor(_darkSwap: DarkSwap);
+}

package/dist/src/services/EventService.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+import { DarkSwap } from '../darkSwap';
+export declare function getOutEvent(tx: string, abi: any, eventTopic: string, darkSwap: DarkSwap): Promise<ethers.LogDescription | null>;

package/dist/src/services/base/deposit.d.ts

@@ -0,0 +1,29 @@
+import { DarkSwap } from '../../darkSwap';
+import { DepositProofResult } from '../../proof/basic/depositProof';
+import { DarkSwapNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+export declare class DepositContext extends BaseContext {
+    private _currentBalance?;
+    private _newBalance?;
+    private _proof?;
+    private _depositAmount?;
+    constructor(signature: string);
+    set currentBalance(currentBalance: DarkSwapNote | undefined);
+    get currentBalance(): DarkSwapNote | undefined;
+    set newBalance(newBalance: DarkSwapNote | undefined);
+    get newBalance(): DarkSwapNote | undefined;
+    set proof(proof: DepositProofResult | undefined);
+    get proof(): DepositProofResult | undefined;
+    set depositAmount(depositAmount: bigint | undefined);
+    get depositAmount(): bigint | undefined;
+}
+export declare class DepositService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(currentBalance: DarkSwapNote, depositAsset: string, depositAmount: bigint, walletAddress: string, signature: string): Promise<{
+        context: DepositContext;
+        newBalanceNote: DarkSwapNote;
+    }>;
+    private generateProof;
+    execute(context: DepositContext): Promise<string>;
+    protected allowance(context: DepositContext): Promise<void>;
+}

package/dist/src/services/base/index.d.ts

@@ -0,0 +1,4 @@
+export * from './deposit';
+export * from './withdraw';
+export * from './join';
+export * from './tripleJoin';

package/dist/src/services/base/join.d.ts

@@ -0,0 +1,29 @@
+import { JoinProofResult } from '../../proof/basic/joinProof';
+import { DarkSwapNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+import { DarkSwap } from '../../darkSwap';
+declare class JoinContext extends BaseContext {
+    private _inNote1?;
+    private _inNote2?;
+    private _outNote?;
+    private _proof?;
+    constructor(signature: string);
+    set inNote1(note: DarkSwapNote | undefined);
+    get inNote1(): DarkSwapNote | undefined;
+    set inNote2(note: DarkSwapNote | undefined);
+    get inNote2(): DarkSwapNote | undefined;
+    set outNote(note: DarkSwapNote | undefined);
+    get outNote(): DarkSwapNote | undefined;
+    set proof(proof: JoinProofResult | undefined);
+    get proof(): JoinProofResult | undefined;
+}
+export declare class JoinService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, inNote1: DarkSwapNote, inNote2: DarkSwapNote, signature: string): Promise<{
+        context: JoinContext;
+        outNotes: DarkSwapNote[];
+    }>;
+    private generateProof;
+    execute(context: JoinContext): Promise<string>;
+}
+export {};

package/dist/src/services/base/tripleJoin.d.ts

@@ -0,0 +1,32 @@
+import { DarkSwap } from '../../darkSwap';
+import { TripleJoinProofResult } from '../../proof/basic/tripleJoinProof';
+import { DarkSwapNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class TripleJoinContext extends BaseContext {
+    private _inNote1?;
+    private _inNote2?;
+    private _inNote3?;
+    private _outNote?;
+    private _proof?;
+    constructor(signature: string);
+    set inNote1(note: DarkSwapNote | undefined);
+    get inNote1(): DarkSwapNote | undefined;
+    set inNote2(note: DarkSwapNote | undefined);
+    get inNote2(): DarkSwapNote | undefined;
+    set inNote3(note: DarkSwapNote | undefined);
+    get inNote3(): DarkSwapNote | undefined;
+    set outNote(note: DarkSwapNote | undefined);
+    get outNote(): DarkSwapNote | undefined;
+    set proof(proof: TripleJoinProofResult | undefined);
+    get proof(): TripleJoinProofResult | undefined;
+}
+export declare class TripleJoinService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, inNote1: DarkSwapNote, inNote2: DarkSwapNote, inNote3: DarkSwapNote, signature: string): Promise<{
+        context: TripleJoinContext;
+        outNotes: DarkSwapNote[];
+    }>;
+    private generateProof;
+    execute(context: TripleJoinContext): Promise<string>;
+}
+export {};

package/dist/src/services/base/withdraw.d.ts

@@ -0,0 +1,29 @@
+import { DarkSwap } from '../../darkSwap';
+import { WithdrawProofResult } from '../../proof/basic/withdrawProof';
+import { DarkSwapNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class WithdrawContext extends BaseContext {
+    private _currentBalance?;
+    private _newBalance?;
+    private _withdrawAmount?;
+    private _proof?;
+    constructor(signature: string);
+    set currentBalance(note: DarkSwapNote | undefined);
+    get currentBalance(): DarkSwapNote | undefined;
+    set newBalance(note: DarkSwapNote | undefined);
+    get newBalance(): DarkSwapNote | undefined;
+    set withdrawAmount(amount: bigint | undefined);
+    get withdrawAmount(): bigint | undefined;
+    set proof(proof: WithdrawProofResult | undefined);
+    get proof(): WithdrawProofResult | undefined;
+}
+export declare class WithdrawService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, currentBalance: DarkSwapNote, withdrawAmount: bigint, signature: string): Promise<{
+        context: WithdrawContext;
+        outNotes: DarkSwapNote[];
+    }>;
+    private generateProof;
+    execute(context: WithdrawContext): Promise<string>;
+}
+export {};

package/dist/src/services/index.d.ts

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

package/dist/src/services/merkletree.d.ts

@@ -0,0 +1,18 @@
+import { DarkSwap } from '../darkSwap';
+export interface MerklePath {
+    noteCommitment: bigint;
+    path: string[];
+    index: number[];
+    root: string;
+}
+export declare const EMPTY_PATH: {
+    path: any[];
+    index: any[];
+    root: string;
+};
+export declare function getMerklePathAndRoot(note: bigint, darkSwap: DarkSwap): Promise<{
+    path: any;
+    index: any;
+    root: any;
+}>;
+export declare function multiGetMerklePathAndRoot(notes: bigint[], darkSwap: DarkSwap): Promise<MerklePath[]>;

package/dist/src/services/noteService.d.ts

@@ -0,0 +1,8 @@
+import { NoteOnChainStatus } from '../entities';
+import { DarkSwap } from '../darkSwap';
+import { DarkSwapNote } from '../types';
+import { Fr } from '@aztec/foundation/fields';
+export declare function getNoteOnChainStatusByPublicKey(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]): Promise<NoteOnChainStatus>;
+export declare function isNoteActive(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]): Promise<boolean>;
+export declare function isNoteSpent(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]): Promise<boolean>;
+export declare function isNoteValid(darkSwap: DarkSwap, note: DarkSwapNote, publicKey: [Fr, Fr]): Promise<boolean>;

package/dist/src/services/pro/cancelOrder.d.ts

@@ -0,0 +1,29 @@
+import { DarkSwap } from '../../darkSwap';
+import { ProCancelOrderProofResult } from '../../proof/pro/orders/cancelOrderProof';
+import { DarkSwapNote, DarkSwapOrderNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class ProCancelOrderContext extends BaseContext {
+    private _orderNote?;
+    private _oldBalance?;
+    private _newBalance?;
+    private _proof?;
+    constructor(signature: string);
+    set orderNote(orderNote: DarkSwapOrderNote | undefined);
+    get orderNote(): DarkSwapOrderNote | undefined;
+    set oldBalance(oldBalance: DarkSwapNote | undefined);
+    get oldBalance(): DarkSwapNote | undefined;
+    set newBalance(newBalance: DarkSwapNote | undefined);
+    get newBalance(): DarkSwapNote | undefined;
+    set proof(proof: ProCancelOrderProofResult | undefined);
+    get proof(): ProCancelOrderProofResult | undefined;
+}
+export declare class ProCancelOrderService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, orderNote: DarkSwapOrderNote, balanceNote: DarkSwapNote, signature: string): Promise<{
+        context: ProCancelOrderContext;
+        newBalance: DarkSwapNote;
+    }>;
+    private generateProof;
+    execute(context: ProCancelOrderContext): Promise<string>;
+}
+export {};

package/dist/src/services/pro/createOrder.d.ts

@@ -0,0 +1,40 @@
+import { DarkSwap } from '../../darkSwap';
+import { ProCreateOrderProofResult } from '../../proof/pro/orders/createOrderProof';
+import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class ProCreateOrderContext extends BaseContext {
+    private _orderNote?;
+    private _oldBalance?;
+    private _newBalance?;
+    private _swapInNote?;
+    private _proof?;
+    private _feeAmount?;
+    private _swapMessage?;
+    constructor(signature: string);
+    set orderNote(orderNote: DarkSwapOrderNote | undefined);
+    get orderNote(): DarkSwapOrderNote | undefined;
+    set swapInNote(swapInNote: DarkSwapNote | undefined);
+    get swapInNote(): DarkSwapNote | undefined;
+    set oldBalance(oldBalance: DarkSwapNote | undefined);
+    get oldBalance(): DarkSwapNote | undefined;
+    set newBalance(newBalance: DarkSwapNote | undefined);
+    get newBalance(): DarkSwapNote | undefined;
+    set feeAmount(feeAmount: bigint | undefined);
+    get feeAmount(): bigint | undefined;
+    set proof(proof: ProCreateOrderProofResult | undefined);
+    get proof(): ProCreateOrderProofResult | undefined;
+    set swapMessage(swapMessage: DarkSwapMessage | undefined);
+    get swapMessage(): DarkSwapMessage | undefined;
+}
+export declare class ProCreateOrderService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, depositAsset: string, depositAmount: bigint, swapInAsset: string, swapInAmount: bigint, balanceNote: DarkSwapNote, signature: string): Promise<{
+        context: ProCreateOrderContext;
+        orderNote: DarkSwapOrderNote;
+        swapInNote: DarkSwapNote;
+        newBalance: DarkSwapNote;
+    }>;
+    private generateProof;
+    execute(context: ProCreateOrderContext): Promise<string>;
+}
+export {};

package/dist/src/services/pro/index.d.ts

@@ -0,0 +1 @@
+export * from './createOrder';

package/dist/src/services/pro/proSwap.d.ts

@@ -0,0 +1,36 @@
+import { DarkSwap } from '../../darkSwap';
+import { ProSwapProofResult } from '../../proof/pro/orders/swapProof';
+import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class ProSwapContext extends BaseContext {
+    private _orderNote?;
+    private _changeNote?;
+    private _swapInNote?;
+    private _proof?;
+    private _bobAddress?;
+    private _bobSwapMessage?;
+    constructor(signature: string);
+    set orderNote(orderNote: DarkSwapOrderNote | undefined);
+    get orderNote(): DarkSwapOrderNote | undefined;
+    set changeNote(changeNote: DarkSwapNote | undefined);
+    get changeNote(): DarkSwapNote | undefined;
+    set swapInNote(swapInNote: DarkSwapNote | undefined);
+    get swapInNote(): DarkSwapNote | undefined;
+    set proof(proof: ProSwapProofResult | undefined);
+    get proof(): ProSwapProofResult | undefined;
+    set bobSwapMessage(bobSwapMessage: DarkSwapMessage | undefined);
+    get bobSwapMessage(): DarkSwapMessage | undefined;
+    set bobAddress(bobAddress: string | undefined);
+    get bobAddress(): string | undefined;
+}
+export declare class ProSwapService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, orderNote: DarkSwapOrderNote, swapOutAmount: bigint, swapInAmount: bigint, bobAddress: string, bobSwapMessage: DarkSwapMessage, signature: string): Promise<{
+        context: ProSwapContext;
+        swapInNote: DarkSwapNote;
+        changeNote: DarkSwapNote;
+    }>;
+    private generateProof;
+    execute(context: ProSwapContext): Promise<string>;
+}
+export {};

package/dist/src/services/retail/cancelAndWithdrawOrder.d.ts

@@ -0,0 +1,22 @@
+import { DarkSwap } from '../../darkSwap';
+import { RetailCancelOrderProofResult } from '../../proof/retail/cancelOrderProof';
+import { DarkSwapOrderNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class RetailCancelOrderContext extends BaseContext {
+    private _orderNote?;
+    private _proof?;
+    constructor(signature: string);
+    set orderNote(orderNote: DarkSwapOrderNote | undefined);
+    get orderNote(): DarkSwapOrderNote | undefined;
+    set proof(proof: RetailCancelOrderProofResult | undefined);
+    get proof(): RetailCancelOrderProofResult | undefined;
+}
+export declare class RetailCancelOrderService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, orderNote: DarkSwapOrderNote, signature: string): Promise<{
+        context: RetailCancelOrderContext;
+    }>;
+    private generateProof;
+    execute(context: RetailCancelOrderContext): Promise<string>;
+}
+export {};

package/dist/src/services/retail/depositAndCreateOrder.d.ts

@@ -0,0 +1,32 @@
+import { DarkSwap } from '../../darkSwap';
+import { RetailCreateOrderProofResult } from '../../proof/retail/depositOrderProof';
+import { DarkSwapMessage, DarkSwapNote, DarkSwapOrderNote } from '../../types';
+import { BaseContext, BaseContractService } from '../BaseService';
+declare class RetailCreateOrderContext extends BaseContext {
+    private _orderNote?;
+    private _swapInNote?;
+    private _proof?;
+    private _feeAmount?;
+    private _swapMessage?;
+    constructor(signature: string);
+    set orderNote(orderNote: DarkSwapOrderNote | undefined);
+    get orderNote(): DarkSwapOrderNote | undefined;
+    set swapInNote(swapInNote: DarkSwapNote | undefined);
+    get swapInNote(): DarkSwapNote | undefined;
+    set feeAmount(feeAmount: bigint | undefined);
+    get feeAmount(): bigint | undefined;
+    set proof(proof: RetailCreateOrderProofResult | undefined);
+    get proof(): RetailCreateOrderProofResult | undefined;
+    set swapMessage(swapMessage: DarkSwapMessage | undefined);
+    get swapMessage(): DarkSwapMessage | undefined;
+}
+export declare class RetailCreateOrderService extends BaseContractService {
+    constructor(_darkSwap: DarkSwap);
+    prepare(address: string, depositAsset: string, depositAmount: bigint, swapInAsset: string, swapInAmount: bigint, signature: string): Promise<{
+        context: RetailCreateOrderContext;
+        swapMessage: DarkSwapMessage;
+    }>;
+    private generateProof;
+    execute(context: RetailCreateOrderContext): Promise<string>;
+}
+export {};

package/dist/src/services/retail/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cancelAndWithdrawOrder';
+export * from './depositAndCreateOrder';

package/dist/src/types.d.ts

@@ -0,0 +1,53 @@
+import { Fr } from "@aztec/foundation/fields";
+export type Hex = `0x${string}`;
+export declare enum PROOF_DOMAIN {
+    DEPOSIT = 10001,
+    WITHDRAW = 10002,
+    RETAIL_CREATE_ORDER = 10003,
+    PRO_CREATE_ORDER = 10004,
+    PRO_SWAP = 10005,
+    PRO_CANCEL_ORDER = 10006,
+    RETAIL_CANCEL_ORDER = 10007,
+    JOIN = 10008,
+    TRIPLE_JOIN = 10009,
+    RETAIL_SWAP = 10010
+}
+export declare const EMPTY_NULLIFIER = 0n;
+export declare const EMPTY_FOOTER = 0n;
+export declare const FEE_RATIO_PRECISION = 1000000n;
+export declare class DarkSwapProofError extends Error {
+    constructor(message: string);
+}
+export type DarkSwapNote = CreateNoteParam & {
+    note: bigint;
+};
+export type DarkSwapOrderNote = DarkSwapNote & {
+    feeRatio: bigint;
+};
+export type CreateNoteParam = {
+    rho: bigint;
+    amount: bigint;
+    asset: string;
+};
+export type DarkSwapNoteExt = DarkSwapNote & {
+    footer: bigint;
+};
+export type BaseProofParam = {
+    address: string;
+    signedMessage: string;
+};
+export type BaseProofResult = {
+    proof: string;
+    verifyInputs: string[];
+};
+export type BaseProofInput = {
+    address: string;
+    pub_key: [string, string];
+    signature: any;
+};
+export type DarkSwapMessage = {
+    orderNote: DarkSwapOrderNote;
+    inNote: DarkSwapNote;
+    publicKey: [Fr, Fr];
+    signature: any;
+};

package/dist/src/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const P: bigint;
+export declare const MAX_ALLOWANCE: bigint;

package/dist/src/utils/encoders.d.ts

@@ -0,0 +1 @@
+export declare function encodeAddress(address: string): bigint;

package/dist/src/utils/formatters.d.ts

@@ -0,0 +1,3 @@
+export declare function bn_to_hex(n: bigint): string;
+export declare function bn_to_0xhex(n: bigint): string;
+export declare function bn_to_0xAddress(n: bigint): string;

package/dist/src/utils/mimc.d.ts

@@ -0,0 +1 @@
+export declare function mimc_bn254(array: bigint[]): bigint;

package/dist/src/utils/proofUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function mergeUnit8Array(arr1: Uint8Array, arr2: Uint8Array): number[];
+export declare function signatureToHexString(sig: [Uint8Array, Uint8Array]): string;
+export declare function hexStringToSignature(hex: string): Uint8Array;
+export declare function uint8ArrayToNumberArray(uint8Array: Uint8Array): number[];

package/dist/src/utils/util.d.ts

@@ -0,0 +1,4 @@
+export declare function isNativeAsset(asset: string): boolean;
+export declare function isAddressEquals(address1: string, address2: string): boolean;
+export declare function hexlify32(value: bigint | number): string;
+export declare function isHexEquals(hex1: string, hex2: string): boolean;

package/dist/test/proof/depositProof.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/proof/keyService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/proof/retail/cancelOrderProof.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/proof/retail/createOrderProof.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/services/depositService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/utils/helpers.d.ts

@@ -0,0 +1,5 @@
+import { ethers } from "ethers";
+import { DarkSwap } from "../../src";
+export declare function getAliceWallet(): ethers.Wallet;
+export declare function getAliceSignature(): Promise<string>;
+export declare function getDarkSwapForAlice(): DarkSwap;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@thesingularitynetwork/darkswap-sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "publishConfig": {
     "access": "public"
   },
   "description": "DarkSwap SDK for browser and Node.js",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.esm.js",
   "files": [
     "dist",
     "src"
@@ -37,6 +39,7 @@
     "eslint": "^9.27.0",
     "prettier": "^3.5.3",
     "rollup": "^4.41.1",
+    "rollup-plugin-dts": "^6.2.1",
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",