@thesingularitynetwork/singularity-sdk-lite 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# singularity-sdk-lite
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Deposit and withdraw only. Same code as
+[`@thesingularitynetwork/singularity-sdk`](https://www.npmjs.com/package/@thesingularitynetwork/singularity-sdk)
+of the same version, built on
+[`@thesingularitynetwork/darkpool-v1-proof-lite`](https://www.npmjs.com/package/@thesingularitynetwork/darkpool-v1-proof-lite)
+instead of the full proof package.
+
+Exports: `DarkPool`, `DepositService`, `DepositContext`, `WithdrawService`, the base service classes,
+`getMerklePathAndRoot`, the note status functions (`isNoteSpent`, `isNoteValid`, ...), `DarkpoolError`, `Relayer`,
+`NoteOnChainStatus`, `WithdrawRelayerRequest` and the hex helpers (`hexlify32`, ...).
+
+Built from the singularity-sdk repository with `yarn build:lite` (output in `lite/`).

package/dist/config/contractConfig.d.ts

@@ -0,0 +1,36 @@
+export declare type ContractConfiguartion = {
+    priceOracle: string;
+    ethAddress: string;
+    nativeWrapper: string;
+    complianceManager: string;
+    merkleTreeOperator: string;
+    darkpoolAssetManager: string;
+    transferAssetManager: string;
+    otcSwapAssetManager: string;
+    stakingOperator: string;
+    stakingAssetManager: string;
+    drakpoolSubgraphUrl: string;
+    batchJoinSplitAssetManager: string;
+    darkpoolSwapAssetManager: string;
+    nftAssetManager: string;
+    theDeepAssetManager?: string;
+    uniswapConfig?: {
+        swapRouterAddress: string;
+        quoterContractAddress: string;
+        wrappedNativeTokenAddress: string;
+        v3PosNftAddress: string;
+        factoryAddress: string;
+        subgraphUrl: string;
+    };
+    sablierConfig?: {
+        aliasPrefixLinear: string;
+        aliasPrefixDynamic: string;
+        lockupLinear: string;
+        lockupDynamic: string;
+        sablierDynamicAssetManager: string;
+        sablierLinearAssetManager: string;
+    };
+};
+export declare const contractConfig: {
+    [chainId: number]: ContractConfiguartion;
+};

package/dist/config/stakingConfig.d.ts

@@ -0,0 +1,8 @@
+import { Token } from '../entities';
+export declare type StakingConfig = {
+    originalToken: Token;
+    stakingToken: Token;
+};
+export declare const stakingTokenConfig: {
+    [chainId: number]: StakingConfig[];
+};

package/dist/darkpool.d.ts

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+import { ContractConfiguartion } from './config/contractConfig';
+import { StakingConfig } from './config/stakingConfig';
+import { Relayer } from './entities/relayer';
+import { ProofOptions } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+export declare class DarkPool {
+    signer: ethers.Signer;
+    provider: ethers.Provider;
+    chainId: number;
+    relayers: Relayer[];
+    contracts: ContractConfiguartion;
+    stakingConfigs: StakingConfig[];
+    proofOptions?: ProofOptions;
+    constructor(signer: ethers.Signer, chainId: number, relayers: Relayer[], contracts?: ContractConfiguartion, stakingConfigs?: StakingConfig[], proofOptions?: ProofOptions);
+    getRelayer(): Relayer;
+}

package/dist/entities/error.d.ts

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

package/dist/entities/index.d.ts

@@ -0,0 +1,6 @@
+export * from './error';
+export * from './relayer';
+export * from './relayerRequestTypes';
+export * from './token';
+export * from './otcswap';
+export * from './types';

package/dist/entities/otcswap.d.ts

@@ -0,0 +1,31 @@
+import { Note, SchnorrSignature } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+export declare type Order = {
+    orderId: string;
+    makerAsset: string;
+    makerAmount: bigint;
+    takerAsset: string;
+    takerAmount: bigint;
+};
+export declare type OTCSwapMakerMessage = {
+    chainId: number;
+    orderId: string;
+    makerNote: Note;
+    makerNoteNullifier: bigint;
+    makerNewFooter: bigint;
+    makerNewRho: bigint;
+    makerPubKey: {
+        x: bigint;
+        y: bigint;
+    };
+};
+export declare type OTCSwapFullMessage = OTCSwapMakerMessage & {
+    takerNote: Note;
+    takerNoteNullifier: bigint;
+    takerNewFooter: bigint;
+    takerNewRho: bigint;
+    takerPubKey: {
+        x: bigint;
+        y: bigint;
+    };
+    takerSignature: SchnorrSignature;
+};

package/dist/entities/relayer.d.ts

@@ -0,0 +1,5 @@
+export declare type Relayer = {
+    relayerName: string;
+    relayerAddress: string;
+    hostUrl: string;
+};

package/dist/entities/relayerRequestTypes.d.ts

@@ -0,0 +1,229 @@
+declare type BaseRelayerRequest = {
+    proof: string;
+    relayer: string;
+    merkleRoot: string;
+    verifierArgs: string[];
+};
+export declare type WithdrawRelayerRequest = BaseRelayerRequest & {
+    asset: string;
+    nullifier: string;
+    recipient: string;
+    amount: string;
+    refund: string;
+};
+export declare type CurveAddLiquidityRelayerRequest = BaseRelayerRequest & {
+    nullifiers: string[];
+    assets: string[];
+    amounts: string[];
+    pool: string;
+    poolType: string;
+    basePoolType: number;
+    lpToken: string;
+    poolFlag: string;
+    booleanFlag: boolean;
+    minMintAmount: string;
+    noteFooter: string;
+    gasRefund: string[];
+};
+export declare type CurveRemoveLiquidityRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    asset: string;
+    amount: string;
+    amountBurn: string;
+    pool: string;
+    poolType: string;
+    basePoolType: number;
+    assetsOut: string[];
+    minExpectedAmountsOut: string[];
+    poolFlag: string;
+    booleanFlag: boolean;
+    noteFooters: string[];
+    gasRefund: string[];
+};
+export declare type CurveMultiExchangeRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    assetIn: string;
+    amountIn: string;
+    routes: string[];
+    swapParams: number[][];
+    pools: string[];
+    routeHash: string;
+    assetOut: string;
+    minExpectedAmountOut: string;
+    noteFooterOut: string;
+    gasRefund: string;
+};
+export declare type UniswapCollectFeesRelayerRequest = BaseRelayerRequest & {
+    tokenId: string;
+    feeNoteFooter1: string;
+    feeNoteFooter2: string;
+    relayerGasFeeFromToken1: string;
+    relayerGasFeeFromToken2: string;
+};
+export declare type UniswapAddLiquidityRelayerRequest = BaseRelayerRequest & {
+    asset1: string;
+    amount1: string;
+    nullifier1: string;
+    asset2: string;
+    amount2: string;
+    nullifier2: string;
+    refundToken1: string;
+    refundToken2: string;
+    changeNoteFooter1: string;
+    changeNoteFooter2: string;
+    tickMin: number;
+    tickMax: number;
+    deadline: string;
+    outNoteFooter: string;
+    feeTier: string;
+    amountMin1: string;
+    amountMin2: string;
+};
+export declare type UniswapRemoveLiquidityRelayerRequest = BaseRelayerRequest & {
+    nftAddress: string;
+    tokenId: string;
+    nullifier: string;
+    outNoteFooter1: string;
+    outNoteFooter2: string;
+    relayerGasFeeFromToken1: string;
+    relayerGasFeeFromToken2: string;
+    deadline: string;
+    amount1Min: string;
+    amount2Min: string;
+};
+export declare type UniswapSwapRelayerRequest = BaseRelayerRequest & {
+    asset: string;
+    amount: string;
+    nullifier: string;
+    assetOut: string;
+    amountOutMin: string;
+    noteFooterOut: string;
+    refund: string;
+    poolFee: string;
+};
+export declare type DefiInfraRelayerRequest = BaseRelayerRequest & {
+    inNoteType: number;
+    inNullifiers: string[];
+    inAssets: string[];
+    inAmountsOrNftIds: string[];
+    contractAddress: string;
+    defiParameters: string;
+    defiParameterHash: string;
+    outNoteType: number;
+    outAssets: string[];
+    outNoteFooters: string[];
+    relayer: string;
+    gasRefund: string[];
+};
+export declare type StakeNoteRelayerRequest = BaseRelayerRequest & {
+    inAsset: string;
+    inNullifier: string;
+    outNoteFooter: string;
+    inAmount: string;
+    refund: string;
+};
+export declare type RedeemRelayerRequest = BaseRelayerRequest & {
+    inNullifier: string;
+    inAsset: string;
+    inAmount: string;
+    outNoteFooter: string;
+    refund: string;
+};
+export declare type AerodromeSwapSwapCommandDataForRelayer = {
+    amountIn: string;
+    amountOutMin: string;
+    hops: string;
+    isUni: boolean;
+};
+export declare type AerodromeSwapRelayerRequest = BaseRelayerRequest & {
+    inNullifier: string;
+    inAsset: string;
+    inAmount: string;
+    outAsset: string;
+    command: string;
+    routes: AerodromeSwapSwapCommandDataForRelayer[];
+    routeHash: string;
+    minExpectedAmountOut: string;
+    deadline: string;
+    outNoteFooter: string;
+    gasRefund: string;
+};
+export declare type AerodromeAddLiquidityRelayerRequest = BaseRelayerRequest & {
+    inNullifier1: string;
+    inNullifier2: string;
+    inAsset1: string;
+    inAsset2: string;
+    inAmount1: string;
+    inAmount2: string;
+    pool: string;
+    stable: boolean;
+    amount1Min: string;
+    amount2Min: string;
+    deadline: string;
+    outNoteFooter: string;
+    outChangeFooter1: string;
+    outChangeFooter2: string;
+    refundToken1: string;
+    refundToken2: string;
+};
+export declare type AerodromeRemoveLiquidityRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    pool: string;
+    amount: string;
+    amountBurn: string;
+    stable: boolean;
+    outAsset1: string;
+    outAsset2: string;
+    outAmount1Min: string;
+    outAmount2Min: string;
+    deadline: string;
+    outNoteFooter1: string;
+    outNoteFooter2: string;
+    outChangeNoteFooter: string;
+    refundToken1: string;
+    refundToken2: string;
+};
+export declare type StakeRocketPoolRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    amount: string;
+    noteFooterOut: string;
+    refund: string;
+};
+export declare type UnstakeRocketPoolRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    amount: string;
+    noteFooterOut: string;
+    refund: string;
+};
+export declare type ClaimStreamSablierRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    stream: string;
+    streamId: string;
+    assetOut: string;
+    amountOut: string;
+    noteFooterOut: string;
+    refund: string;
+};
+export declare type TheDeepNoteDepositRelayerRequest = BaseRelayerRequest & {
+    vaultType: string;
+    asset1: string;
+    amount1: string;
+    asset2: string;
+    amount2: string;
+    inNullifier1: string;
+    inNullifier2: string;
+    noteFooter: string;
+    vaultAddress: string;
+    volatility: string;
+    refund1: string;
+    refund2: string;
+};
+export declare type TheDeepWithdrawRelayerRequest = BaseRelayerRequest & {
+    nullifier: string;
+    vaultAddress: string;
+    amount: string;
+    receipt: string;
+    refund1: string;
+    refund2: string;
+};
+export {};

package/dist/entities/token.d.ts

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

package/dist/entities/types.d.ts

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

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./singularity-sdk-lite.cjs.production.min.js')
+} else {
+  module.exports = require('./singularity-sdk-lite.cjs.development.js')
+}

package/dist/lite.d.ts

@@ -0,0 +1,11 @@
+export * from './services/base/deposit';
+export * from './services/base/withdraw';
+export * from './services/BaseService';
+export * from './services/merkletree';
+export * from './services/noteService';
+export * from './entities/error';
+export * from './entities/relayer';
+export * from './entities/types';
+export type { WithdrawRelayerRequest } from './entities/relayerRequestTypes';
+export * from './darkpool';
+export * from './utils/util';

package/dist/services/BaseService.d.ts

@@ -0,0 +1,64 @@
+import { Note, PartialNote } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+import { Relayer } from '../entities/relayer';
+import { DarkPool } from '../darkpool';
+export declare class BaseContext {
+    private _signature;
+    private _merkleRoot?;
+    private _tx?;
+    constructor(signature: string);
+    get signature(): string;
+    set merkleRoot(merkleRoot: string | undefined);
+    get merkleRoot(): string | undefined;
+    set tx(tx: string | undefined);
+    get tx(): string | undefined;
+}
+export declare class BaseRelayerContext extends BaseContext {
+    private _relayer;
+    private _jobId?;
+    constructor(relayer: Relayer, signature: string);
+    get relayer(): Relayer;
+    set jobId(jobId: string | undefined);
+    get jobId(): string | undefined;
+}
+export interface BaseRelayerResult {
+    txHash: string;
+}
+export interface MultiWithdrawResult extends BaseRelayerResult {
+    outAmounts: bigint[];
+}
+export interface SingleNoteResult extends BaseRelayerResult {
+    note: Note;
+}
+export interface MultiNotesResult extends BaseRelayerResult {
+    notes: Note[];
+}
+export declare abstract class BaseContractService<T> {
+    protected _darkPool: DarkPool;
+    constructor(_darkPool: DarkPool);
+    abstract prepare(...args: any[]): Promise<{
+        context: T;
+        outNotes: Note[];
+    }>;
+    abstract generateProof(context: T): Promise<void>;
+    abstract execute(context: T): Promise<string>;
+}
+export declare abstract class BaseRelayerService<T extends BaseRelayerContext, R, S extends BaseRelayerResult> {
+    protected _darkPool: DarkPool;
+    constructor(_darkPool: DarkPool);
+    abstract prepare(...args: any[]): Promise<{
+        context: T;
+        outPartialNotes: PartialNote[];
+    }>;
+    abstract generateProof(context: T): Promise<void>;
+    protected abstract getRelayerRequest(context: T): Promise<R>;
+    protected abstract getRelayerPath(): string;
+    protected abstract postExecute(context: T): Promise<S>;
+    execute(context: T): Promise<string>;
+    executeAndWaitForResult(context: T): Promise<S>;
+    pollJobStatus(context: T): Promise<{
+        error: string | undefined;
+        txHash: string | undefined;
+    }>;
+}
+export declare function transferCodeToNoteFooter(transferCode: string, chainId: number): bigint;
+export declare function validateRecipientCode(code: string): boolean;

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

@@ -0,0 +1,32 @@
+import { DepositProofResult, Note } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+import { DarkPool } from '../../darkpool';
+import { BaseContext, BaseContractService } from '../BaseService';
+export declare class DepositContext extends BaseContext {
+    private _note?;
+    private _address?;
+    private _proof?;
+    constructor(signature: string);
+    set note(note: Note | undefined);
+    get note(): Note | undefined;
+    set address(address: string | undefined);
+    get address(): string | undefined;
+    set proof(proof: DepositProofResult | undefined);
+    get proof(): DepositProofResult | undefined;
+}
+export declare class DepositService extends BaseContractService<DepositContext> {
+    constructor(_darkPool: DarkPool);
+    prepare(asset: string, amount: bigint, walletAddress: string, signature: string): Promise<{
+        context: DepositContext;
+        outNotes: Note[];
+    }>;
+    generateProof(context: DepositContext): Promise<void>;
+    execute(context: DepositContext): Promise<string>;
+    protected allowance(context: DepositContext): Promise<void>;
+    getContractCallParameters(context: DepositContext): {
+        proof: string;
+        asset: string;
+        amount: string;
+        note: string;
+        noteFooter: string;
+    };
+}

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

@@ -0,0 +1,38 @@
+import { Note, PartialNote, WithdrawProofResult } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+import { WithdrawRelayerRequest } from '../../entities/relayerRequestTypes';
+import { BaseRelayerContext, BaseRelayerResult, BaseRelayerService } from '../BaseService';
+import { Relayer } from '../../entities/relayer';
+import { DarkPool } from '../../darkpool';
+declare class WithdrawContext extends BaseRelayerContext {
+    private _note?;
+    private _recipient?;
+    private _proof?;
+    constructor(relayer: Relayer, signature: string);
+    set note(note: Note | undefined);
+    get note(): Note | undefined;
+    set recipient(recipient: string | undefined);
+    get recipient(): string | undefined;
+    set proof(proof: WithdrawProofResult | undefined);
+    get proof(): WithdrawProofResult | undefined;
+}
+export declare class WithdrawService extends BaseRelayerService<WithdrawContext, WithdrawRelayerRequest, BaseRelayerResult> {
+    constructor(_darkPool: DarkPool);
+    prepare(note: Note, recipient: string, signature: string): Promise<{
+        context: WithdrawContext;
+        outPartialNotes: PartialNote[];
+    }>;
+    generateProof(context: WithdrawContext): Promise<void>;
+    getRelayerRequest(context: WithdrawContext): Promise<WithdrawRelayerRequest>;
+    getRelayerPath(): string;
+    postExecute(context: WithdrawContext): Promise<BaseRelayerResult>;
+    getRelayerContractCallParameters(context: WithdrawContext): {
+        proof: string;
+        asset: string;
+        merkleRoot: string | undefined;
+        nullifier: string;
+        recipient: string;
+        relayer: string;
+        amount: string;
+    };
+}
+export {};

package/dist/services/merkletree.d.ts

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

package/dist/services/noteService.d.ts

@@ -0,0 +1,10 @@
+import { Note } from '@thesingularitynetwork/darkpool-v1-proof-lite';
+import { DarkPool } from '../darkpool';
+import { NoteOnChainStatus } from '../entities';
+export declare function getNoteOnChainStatusByPublicKey(darkPool: DarkPool, note: Note, publicKey: any): Promise<NoteOnChainStatus>;
+export declare function getNoteOnChainStatusBySignature(darkPool: DarkPool, note: Note, signature: string): Promise<NoteOnChainStatus>;
+export declare function isNoteActive(darkPool: DarkPool, note: Note, signature: string): Promise<boolean>;
+export declare function isNoteSpent(darkPool: DarkPool, note: Note, signature: string): Promise<boolean>;
+export declare function isNoteLocked(darkPool: DarkPool, note: Note, signature: string): Promise<boolean>;
+export declare function isNoteValid(note: Note, signature: string): Promise<boolean>;
+export declare function isNftNoteValid(note: Note, signature: string): Promise<boolean>;