@thesingularitynetwork/darkswap-sdk 0.1.0 → 0.1.2

package/dist/index.esm.js

@@ -5183,5 +5183,5 @@ class DarkSwap {
     }
 }
 
-export { DarkSwap, DarkSwapError, DepositContext, DepositService, EMPTY_PATH, JoinService, NoteOnChainStatus, ProCreateOrderService, RetailCancelOrderService, RetailCreateOrderService, TripleJoinService, WithdrawService, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, multiGetMerklePathAndRoot };
+export { ChainId, DarkSwap, DarkSwapError, DarkSwapProofError, DepositContext, DepositService, EMPTY_FOOTER, EMPTY_NULLIFIER, EMPTY_PATH, FEE_RATIO, FEE_RATIO_PRECISION, JoinService, NoteOnChainStatus, PROOF_DOMAIN, ProCreateOrderService, RetailCancelOrderService, RetailCreateOrderService, TripleJoinService, WithdrawService, contractConfig, generateKeyPair, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, legacyTokenConfig, multiGetMerklePathAndRoot };
 //# sourceMappingURL=index.esm.js.map

package/dist/index.js

@@ -5183,5 +5183,5 @@ class DarkSwap {
     }
 }
 
-export { DarkSwap, DarkSwapError, DepositContext, DepositService, EMPTY_PATH, JoinService, NoteOnChainStatus, ProCreateOrderService, RetailCancelOrderService, RetailCreateOrderService, TripleJoinService, WithdrawService, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, multiGetMerklePathAndRoot };
+export { ChainId, DarkSwap, DarkSwapError, DarkSwapProofError, DepositContext, DepositService, EMPTY_FOOTER, EMPTY_NULLIFIER, EMPTY_PATH, FEE_RATIO, FEE_RATIO_PRECISION, JoinService, NoteOnChainStatus, PROOF_DOMAIN, ProCreateOrderService, RetailCancelOrderService, RetailCreateOrderService, TripleJoinService, WithdrawService, contractConfig, generateKeyPair, getMerklePathAndRoot, getNoteOnChainStatusByPublicKey, hexlify32, isAddressEquals, isHexEquals, isNativeAsset, isNoteActive, isNoteSpent, isNoteValid, legacyTokenConfig, multiGetMerklePathAndRoot };
 //# sourceMappingURL=index.js.map

package/dist/index.umd.js

@@ -2411,7 +2411,7 @@
   var ERC20_USDT = {
   	abi: abi$6};
 
-  var ChainId;
+  exports.ChainId = void 0;
   (function (ChainId) {
       ChainId[ChainId["HARDHAT"] = 31337] = "HARDHAT";
       ChainId[ChainId["HARDHAT_ARBITRUM"] = 31338] = "HARDHAT_ARBITRUM";
@@ -2420,11 +2420,11 @@
       ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
       ChainId[ChainId["ARBITRUM_ONE"] = 42161] = "ARBITRUM_ONE";
       ChainId[ChainId["BASE"] = 8453] = "BASE";
-  })(ChainId || (ChainId = {}));
+  })(exports.ChainId || (exports.ChainId = {}));
 
   const legacyTokenConfig = {
-      [ChainId.MAINNET]: ['0xdac17f958d2ee523a2206206994597c13d831ec7'],
-      [ChainId.HARDHAT]: ['0xdac17f958d2ee523a2206206994597c13d831ec7']
+      [exports.ChainId.MAINNET]: ['0xdac17f958d2ee523a2206206994597c13d831ec7'],
+      [exports.ChainId.HARDHAT]: ['0xdac17f958d2ee523a2206206994597c13d831ec7']
   };
   const FEE_RATIO = 300n;
 
@@ -2633,7 +2633,7 @@
   	brillig_names: brillig_names$5
   };
 
-  var PROOF_DOMAIN;
+  exports.PROOF_DOMAIN = void 0;
   (function (PROOF_DOMAIN) {
       PROOF_DOMAIN[PROOF_DOMAIN["DEPOSIT"] = 10001] = "DEPOSIT";
       PROOF_DOMAIN[PROOF_DOMAIN["WITHDRAW"] = 10002] = "WITHDRAW";
@@ -2645,7 +2645,7 @@
       PROOF_DOMAIN[PROOF_DOMAIN["JOIN"] = 10008] = "JOIN";
       PROOF_DOMAIN[PROOF_DOMAIN["TRIPLE_JOIN"] = 10009] = "TRIPLE_JOIN";
       PROOF_DOMAIN[PROOF_DOMAIN["RETAIL_SWAP"] = 10010] = "RETAIL_SWAP";
-  })(PROOF_DOMAIN || (PROOF_DOMAIN = {}));
+  })(exports.PROOF_DOMAIN || (exports.PROOF_DOMAIN = {}));
   const EMPTY_NULLIFIER = 0n;
   const EMPTY_FOOTER = 0n;
   const FEE_RATIO_PRECISION = 1000000n;
@@ -2713,7 +2713,7 @@
       const newBalanceFooter = getNoteFooter(param.newBalanceNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.DEPOSIT),
+          BigInt(exports.PROOF_DOMAIN.DEPOSIT),
           oldBalanceNullifier,
           addressMod,
           param.newBalanceNote.note,
@@ -3187,7 +3187,7 @@
       const addressMod = encodeAddress(param.address);
       const assetMod = encodeAddress(param.oldBalance.asset);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.WITHDRAW),
+          BigInt(exports.PROOF_DOMAIN.WITHDRAW),
           addressMod,
           oldBalanceNullifier,
           param.newBalance.note,
@@ -3579,7 +3579,7 @@
       const outNoteFooter = getNoteFooter(param.outNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.JOIN),
+          BigInt(exports.PROOF_DOMAIN.JOIN),
           inNullifier1,
           inNullifier2,
           param.outNote.note,
@@ -4043,7 +4043,7 @@
       const outNoteFooter = getNoteFooter(param.outNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.TRIPLE_JOIN),
+          BigInt(exports.PROOF_DOMAIN.TRIPLE_JOIN),
           inNullifier1,
           inNullifier2,
           inNullifier3,
@@ -4245,7 +4245,7 @@
       const orderNoteFooter = getNoteFooter(param.orderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.PRO_CREATE_ORDER),
+          BigInt(exports.PROOF_DOMAIN.PRO_CREATE_ORDER),
           oldBalanceNullifier,
           addressMod,
           param.newBalanceNote.note,
@@ -4621,7 +4621,7 @@
       const nullifier = calcNullifier(param.orderNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.RETAIL_CANCEL_ORDER),
+          BigInt(exports.PROOF_DOMAIN.RETAIL_CANCEL_ORDER),
           addressMod,
           nullifier,
           param.orderNote.feeRatio,
@@ -4916,7 +4916,7 @@
       const addressMod = encodeAddress(address);
       calcNullifier(orderNote.rho, pubKey);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
+          BigInt(exports.PROOF_DOMAIN.RETAIL_CREATE_ORDER),
           addressMod,
           orderNote.note,
           orderNote.feeRatio,
@@ -4944,7 +4944,7 @@
       const swapInNoteFooter = getNoteFooter(param.swapInNote.rho, [fuzkPubKeyX, fuzkPubKeyY]);
       const addressMod = encodeAddress(param.address);
       const message = bn_to_hex(mimc_bn254([
-          BigInt(PROOF_DOMAIN.RETAIL_CREATE_ORDER),
+          BigInt(exports.PROOF_DOMAIN.RETAIL_CREATE_ORDER),
           addressMod,
           param.depositNote.note,
           param.depositNote.feeRatio,
@@ -5091,7 +5091,7 @@
   }
 
   const contractConfig = {
-      [ChainId.MAINNET]: {
+      [exports.ChainId.MAINNET]: {
           priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
           ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
           nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
@@ -5100,7 +5100,7 @@
           darkSwapFeeAssetManager: '0x0', //FIXME
           drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-subgraph/version/v0.0.1/api',
       },
-      [ChainId.ARBITRUM_ONE]: {
+      [exports.ChainId.ARBITRUM_ONE]: {
           priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
           ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
           nativeWrapper: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
@@ -5109,7 +5109,7 @@
           darkSwapFeeAssetManager: '0x0', //FIXME
           drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-arb-subgraph/api'
       },
-      [ChainId.BASE]: {
+      [exports.ChainId.BASE]: {
           priceOracle: '0xf224a25453D76A41c4427DD1C05369BC9f498444',
           ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
           nativeWrapper: '0x4200000000000000000000000000000000000006',
@@ -5118,7 +5118,7 @@
           darkSwapFeeAssetManager: '0x0', //FIXME
           drakpoolSubgraphUrl: 'https://subgraph.satsuma-prod.com/1c6a44a9ed6e/pgs-team--611591/singularity-base-subgraph/api'
       },
-      [ChainId.SEPOLIA]: {
+      [exports.ChainId.SEPOLIA]: {
           priceOracle: '0x4Fe44a9aC8Ef059Be2dB97f9e3bcA32Ab698C2f2',
           ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
           nativeWrapper: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
@@ -5127,7 +5127,7 @@
           darkSwapFeeAssetManager: '0x0', //FIXME
           drakpoolSubgraphUrl: ''
       },
-      [ChainId.HARDHAT]: {
+      [exports.ChainId.HARDHAT]: {
           priceOracle: '0x0AdDd25a91563696D8567Df78D5A01C9a991F9B8',
           ethAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
           nativeWrapper: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
@@ -5185,15 +5185,22 @@
 
   exports.DarkSwap = DarkSwap;
   exports.DarkSwapError = DarkSwapError;
+  exports.DarkSwapProofError = DarkSwapProofError;
   exports.DepositContext = DepositContext;
   exports.DepositService = DepositService;
+  exports.EMPTY_FOOTER = EMPTY_FOOTER;
+  exports.EMPTY_NULLIFIER = EMPTY_NULLIFIER;
   exports.EMPTY_PATH = EMPTY_PATH;
+  exports.FEE_RATIO = FEE_RATIO;
+  exports.FEE_RATIO_PRECISION = FEE_RATIO_PRECISION;
   exports.JoinService = JoinService;
   exports.ProCreateOrderService = ProCreateOrderService;
   exports.RetailCancelOrderService = RetailCancelOrderService;
   exports.RetailCreateOrderService = RetailCreateOrderService;
   exports.TripleJoinService = TripleJoinService;
   exports.WithdrawService = WithdrawService;
+  exports.contractConfig = contractConfig;
+  exports.generateKeyPair = generateKeyPair;
   exports.getMerklePathAndRoot = getMerklePathAndRoot;
   exports.getNoteOnChainStatusByPublicKey = getNoteOnChainStatusByPublicKey;
   exports.hexlify32 = hexlify32;
@@ -5203,6 +5210,7 @@
   exports.isNoteActive = isNoteActive;
   exports.isNoteSpent = isNoteSpent;
   exports.isNoteValid = isNoteValid;
+  exports.legacyTokenConfig = legacyTokenConfig;
   exports.multiGetMerklePathAndRoot = multiGetMerklePathAndRoot;
 
 }));

package/dist/index.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/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/types/src/config/config.d.ts

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

package/dist/types/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/types/src/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chain';
+export * from './config';
+export * from './contractConfig';

package/dist/types/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/types/src/entities/error.d.ts

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

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

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

package/dist/types/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/types/src/entities/types.d.ts

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

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

@@ -0,0 +1,7 @@
+export * from './services';
+export * from './entities';
+export * from './darkSwap';
+export * from './utils/util';
+export * from './proof/keyService';
+export * from './config';
+export * from './types';

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/src/services/base/index.d.ts

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

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/src/services/pro/index.d.ts

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

package/dist/types/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/types/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/types/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/types/src/services/retail/index.d.ts

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

package/dist/types/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/types/src/utils/constants.d.ts

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

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

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

package/dist/types/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/types/src/utils/mimc.d.ts

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

package/dist/types/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/types/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/types/test/proof/depositProof.test.d.ts

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

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

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

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

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

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

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

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

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

package/dist/types/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,18 +1,18 @@
 {
   "name": "@thesingularitynetwork/darkswap-sdk",
-  "version": "0.1.0",
-  "publishConfig": {
-    "access": "public"
-  },
+  "version": "0.1.2",
   "description": "DarkSwap SDK for browser and Node.js",
   "type": "module",
+  "types": "dist/types/index.d.ts",
   "main": "dist/index.js",
   "files": [
     "dist",
     "src"
   ],
   "scripts": {
-    "build": "rollup -c --bundleConfigAsCjs",
+    "build:types": "tsc -p tsconfig.json",
+    "build:js": "rollup -c",
+    "build": "yarn build:types && yarn build:js",
     "dev": "rollup -c --bundleConfigAsCjs -w",
     "test": "vitest",
     "lint": "eslint src --ext .ts",

package/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from './chain';
+export * from './config';
+export * from './contractConfig';

package/src/index.ts

@@ -2,3 +2,6 @@ export * from './services';
 export * from './entities';
 export * from './darkSwap';
 export * from './utils/util';
+export * from './proof/keyService';
+export * from './config';
+export * from './types';