@hinkal/common 0.2.12 → 0.2.14

package/types/sandbox.types.d.ts

@@ -0,0 +1,157 @@
+import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
+import { EncryptedOutputWithSign } from './commitments.types';
+import { ExternalActionId } from './external-action.types';
+import { ApprovedUtxo, FeeStructure, IntegrationProvider } from './hinkal.types';
+import { ERC20Token, TokenChanges } from './token.types';
+import { AppMetaData, WCTransactionParameters } from './wc.types';
+import { WithId } from './with-id.types';
+export declare enum SandboxRequestType {
+    TransferToken = "TransferToken",
+    ReceiveFromShieldedAccount = "ReceiveFromShieldedAccount",
+    SwapTokens = "SwapTokens",
+    ShieldTokens = "ShieldTokens",
+    MintAccessToken = "MintAccessToken",
+    SignMessage = "SignMessage",
+    FundApproveAndTransact = "FundApproveAndTransact",
+    PrivateTransactionFromProxy = "PrivateTransactionFromProxy",
+    Approve = "Approve",
+    InsideTransact = "InsideTransact",
+    ProxySend = "ProxySend",
+    ProxySwapTokens = "ProxySwapTokens"
+}
+export interface SandboxTransferableTransaction {
+    hash: string;
+    from: string;
+    to: string;
+    gas: bigint;
+    gasPrice: bigint;
+    value: bigint;
+    isRelayerOff: boolean;
+}
+export interface TransferTokenRequest {
+    type: SandboxRequestType.TransferToken;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    to: string;
+    isRelayerOff: boolean;
+    ownerPublicAddress: string;
+    feeToken?: string;
+    isFund?: boolean;
+}
+export interface PrivateTransactionBaseRequest {
+    txParams: WCTransactionParameters;
+    appMetaData: AppMetaData;
+    feeToken?: string;
+}
+export interface FundApproveAndTransactRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.FundApproveAndTransact;
+    walletNonce: bigint;
+    tokenChanges: TokenChanges<bigint>[];
+}
+export interface PrivateTransactionFromProxyRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.PrivateTransactionFromProxy;
+    walletNonce: bigint;
+    tokenChanges: TokenChanges<bigint>[];
+}
+export interface ApproveRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.Approve;
+    approvalAmount: string;
+    approvalToken: ERC20Token;
+}
+export interface InsideTransactRequest extends PrivateTransactionBaseRequest {
+    type: SandboxRequestType.InsideTransact;
+    tokenChanges: TokenChanges<bigint>[];
+}
+export interface ReceiveFromSubAccountRequest {
+    type: SandboxRequestType.ReceiveFromShieldedAccount;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    walletNonce: bigint;
+    ownerPublicAddress: string;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface ShieldTokensRequest {
+    type: SandboxRequestType.ShieldTokens;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    ownerPublicAddress: string;
+}
+export interface SwapTokensRequest {
+    type: SandboxRequestType.SwapTokens;
+    amountChanges: bigint[];
+    erc20Tokens: ERC20Token[];
+    externalActionId: ExternalActionId;
+    swapData: string;
+    isVolatile: boolean;
+    ownerPublicAddress: string;
+    integrationProvider: IntegrationProvider;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface ProxySwapTokensRequest {
+    type: SandboxRequestType.ProxySwapTokens;
+    amountChanges: bigint[];
+    erc20Tokens: ERC20Token[];
+    externalActionId: ExternalActionId;
+    swapData: string;
+    ownerPublicAddress: string;
+    integrationProvider: IntegrationProvider;
+    walletNonce: bigint;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface SignMessageRequest {
+    type: SandboxRequestType.SignMessage;
+    dataHash: string;
+    walletNonce: bigint;
+    shouldBeProxyDeployed?: boolean;
+    feeToken?: string;
+}
+export interface SendProxySendRequest {
+    type: SandboxRequestType.ProxySend;
+    amounts: bigint[];
+    erc20Tokens: ERC20Token[];
+    to: string;
+    walletNonce: bigint;
+    ownerPublicAddress: string;
+    feeToken?: string;
+    feeStructure?: FeeStructure;
+}
+export interface PrepareHinkalFromSerializedArgs {
+    signature: string;
+    ethereumAddress: string;
+    chainId: number;
+    nullifiers: string[];
+    merkleTreeHinkal: MerkleTreeJson;
+    merkleTreeAccessToken: MerkleTreeJson;
+    encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+    approvals: Record<string, ApprovedUtxo[]>;
+    generateProofRemotely: boolean;
+    serializedCache: Record<string, string>;
+    stealthPairCache: Record<string, string>;
+    stealthAddressCache: Record<string, string>;
+}
+export type SandboxRequest = (TransferTokenRequest | ReceiveFromSubAccountRequest | SwapTokensRequest | ShieldTokensRequest | SignMessageRequest | FundApproveAndTransactRequest | PrivateTransactionFromProxyRequest | ApproveRequest | InsideTransactRequest | SendProxySendRequest | ProxySwapTokensRequest) & {
+    prepareHinkalArgs: PrepareHinkalFromSerializedArgs;
+};
+export type SandboxRuntimeMessageHandler = (message: WithId<SandboxRequest>) => Promise<{
+    result: string;
+} | undefined>;
+export interface SandboxResponseError {
+    id: number;
+    success: false;
+    error: Error;
+}
+export interface SandboxResponseBase {
+    id: number;
+    success: true;
+}
+export interface SandboxResponseTx extends SandboxResponseBase {
+    tx: SandboxTransferableTransaction;
+}
+export interface SandboxResponseSignature extends SandboxResponseBase {
+    signature: string;
+}
+export type SandboxResponseSuccess = SandboxResponseTx | SandboxResponseSignature;
+export type SandboxResponse = SandboxResponseError | SandboxResponseSuccess;

package/types/sandbox.types.mjs

@@ -0,0 +1,4 @@
+var n = /* @__PURE__ */ ((r) => (r.TransferToken = "TransferToken", r.ReceiveFromShieldedAccount = "ReceiveFromShieldedAccount", r.SwapTokens = "SwapTokens", r.ShieldTokens = "ShieldTokens", r.MintAccessToken = "MintAccessToken", r.SignMessage = "SignMessage", r.FundApproveAndTransact = "FundApproveAndTransact", r.PrivateTransactionFromProxy = "PrivateTransactionFromProxy", r.Approve = "Approve", r.InsideTransact = "InsideTransact", r.ProxySend = "ProxySend", r.ProxySwapTokens = "ProxySwapTokens", r))(n || {});
+export {
+  n as SandboxRequestType
+};

package/types/tenderly.api.types.d.ts

@@ -0,0 +1,180 @@
+export interface SendTransacrtionBase {
+    blockOverrides?: {
+        number: string;
+        timestamp: string;
+    };
+    stateOverrides?: {
+        nonce: number;
+        code: string;
+        balance: {
+            value: number;
+        };
+        storage: Map<string, string>;
+    };
+}
+export type SimulateTxBody = {
+    network_id: string;
+    from: string;
+    to: string;
+    input: string;
+    gas?: number;
+    block_number?: number;
+    transaction_index?: number;
+    gas_price?: string;
+    estimate_gas?: boolean;
+    value?: string;
+    save?: boolean;
+    save_if_fails?: boolean;
+};
+export type SimulateTxResponse = {
+    transaction: {
+        hash: string;
+        block_hash: string;
+        block_number: number;
+        from: string;
+        gas: number;
+        gas_price: number;
+        input: string;
+        nonce: number;
+        to: string;
+        index: number;
+        addresses: string[];
+        contract_ids: string[];
+        network_id: string;
+        timestamp: string;
+        transaction_info: {
+            contract_address: string;
+            method: 'approve';
+            logs: any[] | null;
+            balance_diff: any[] | null;
+            nonce_diff: any[] | null;
+            state_diff: any[] | null;
+            asset_changes: any[] | null;
+            exposure_changes: any[] | null;
+            balance_changes: any[] | null;
+        };
+        call_trace: any[] | null;
+        simulation: {
+            id: string;
+            project_id: string;
+            network_id: string;
+            blocknumber: number;
+            transaction_index: number;
+            block_header: object;
+            nonce: number;
+            contracts: any[];
+        };
+    };
+    simulation: object;
+};
+export type RpcTransactionParams = {
+    from: string;
+    to: string;
+    gas: string;
+    gasPrice?: string;
+    value: string | bigint;
+    input: string;
+    maxFeePerGas?: number;
+    maxPriorityFeePerGas?: number;
+};
+export type RpcSimulateTransactionBody<T extends RpcTransactionParams | RpcTransactionParams[] = RpcTransactionParams> = {
+    params: [
+        T,
+        string | 'latest' | 'earliest' | 'pending' | 'finalized' | 'safe',
+        {
+            [key in string]: {
+                balance: string;
+                nonce?: string;
+            };
+        }
+    ];
+};
+export type StorageStateChange = {
+    address: string;
+    balance?: {
+        previousValue: string;
+        newValue: string;
+    };
+    nonce?: {
+        previousValue: string;
+        newValue: string;
+    };
+    storage?: {
+        slot: string;
+        previousValue: string;
+        newValue: string;
+        ERC20ChangeType?: 'balance' | 'allowance';
+    }[];
+};
+export type RPCSimulationAssetChange = {
+    rawAmount: string;
+    amount: string | null;
+    dollarValue?: string;
+    from: string;
+    to: string;
+    assetInfo: {
+        standard: string;
+        type: string;
+        contractAddress?: string;
+        symbol?: string;
+        name?: string;
+        logo?: string;
+        decimals?: number;
+        dollarValue?: string;
+    };
+};
+export type RPCSimulationExposureChange = {
+    assetInfo: {
+        standard: string;
+        type: string;
+        contractAddress: string;
+        symbol: string;
+        name: string;
+        logo: string;
+        decimals: number;
+        dollarValue: string;
+    };
+    type: string;
+    owner: string;
+    spender: string;
+    rawAmount: string;
+    amount: string;
+    dollarValue: string;
+};
+export type RpcSimulateResult = {
+    assetChanges: RPCSimulationAssetChange[];
+    status: boolean;
+    gasUsed: string;
+    cumulativeGasUsed: string;
+    blockNumber: string;
+    type: string;
+    logsBloom: string;
+    logs: {
+        name: string;
+        inputs: {
+            value: string;
+            type: string;
+            name: string;
+            indexed: boolean;
+        }[];
+        raw: {
+            address: string;
+            data: string;
+            topics: string[];
+        };
+    }[];
+    stateChanges: StorageStateChange[];
+    trace: {
+        type: string;
+        method: string;
+        output: string;
+        subtraces: number;
+        traceAddress: string[];
+    }[];
+    exposureChanges: RPCSimulationExposureChange[];
+};
+export type RpcSimulateTransactionResponse<T extends RpcSimulateResult | RpcSimulateResult[] = RpcSimulateResult> = {
+    jsonrpc: '2.0';
+    id: 0;
+    result: T;
+};

package/types/token-with-id.types.d.ts

@@ -0,0 +1,4 @@
+export interface TokenWithId {
+    erc20TokenAddress: string;
+    tokenId: number;
+}

package/types/token.types.d.ts

@@ -18,6 +18,9 @@ export interface ERC20Token {
     isHToken?: boolean;
     hasHToken?: boolean;
     aaveToken?: boolean;
+    allowanceStorageOffset?: number;
+    balanceStorageOffset?: number;
+    isVyper?: boolean;
 }
 export declare enum ApprovalType {
     Classic = 0,
@@ -34,3 +37,23 @@ export interface TokenBalance {
     timestamp?: string;
     nfts?: NFT[];
 }
+export interface TokenBalanceWithUsdValue extends TokenBalance {
+    usdValue: number;
+}
+export interface PublicTokenBalances {
+    publicTokenBalances: TokenBalance[];
+    isPublicBalancesLoading: boolean;
+}
+export interface PublicTokenBalancesWithUsd {
+    publicTokenBalancesWithUSD: TokenBalanceWithUsdValue[];
+    publicUsdBalance: number;
+    isPublicBalancesLoading: boolean;
+}
+export interface TokenChangesMinimal<T = number> {
+    token: ERC20Token;
+    amount: T;
+    dollarValue?: string;
+}
+export type TokenChanges<T = number> = TokenChangesMinimal<T> & {
+    dollarValue: string;
+};

package/types/transactions.types.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("ethers"),o=e.BigNumber.from(0),r={blockNumber:0,timeStamp:0,methodId:"",input:"",decodedInput:{erc20TokenAddresses:[],amountChanges:[],flatFees:[0n,0n].map(t=>e.BigNumber.from(t)),externalActionId:o,externalActionMetadata:"",encryptedOutputs:[],hookData:{hookContract:"",preHookContract:"",preHookMetadata:"",postHookMetadata:""},stealthAddressStructure:{extraRandomization:0n,stealthAddress:0n,H0:0n,H1:0n}},logs:[],hash:"",gas:0,gasPrice:0,isError:"",status:""};exports.emptyDecodedTx=r;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("ethers"),l=d.BigNumber.from(0),p={blockNumber:0,timeStamp:0,methodId:"",input:"",decodedInput:{erc20TokenAddresses:[],amountChanges:[],flatFees:[0n,0n].map(e=>d.BigNumber.from(e)),externalActionId:l,externalActionMetadata:"",encryptedOutputs:[],hookData:{hookContract:"",preHookContract:"",preHookMetadata:"",postHookMetadata:""},stealthAddressStructure:{extraRandomization:0n,stealthAddress:0n,H0:0n,H1:0n}},logs:[],hash:"",gas:0,gasPrice:0,isError:"",status:""};var u=(e=>(e[e.Confirmed=0]="Confirmed",e[e.Failed=1]="Failed",e[e.Loading=2]="Loading",e[e.NotStarted=3]="NotStarted",e))(u||{}),m=(e=>(e[e.None=0]="None",e[e.Deposit=1]="Deposit",e[e.Mint=2]="Mint",e[e.PoolAdd=3]="PoolAdd",e[e.PoolRemove=4]="PoolRemove",e[e.Redeem=5]="Redeem",e[e.Swap=6]="Swap",e[e.Transfer=7]="Transfer",e[e.Withdraw=8]="Withdraw",e[e.Send=9]="Send",e[e.CurveDeposit=10]="CurveDeposit",e[e.CurveWithdraw=11]="CurveWithdraw",e[e.CurveStake=12]="CurveStake",e[e.CurveUnstake=13]="CurveUnstake",e[e.CurveClaim=14]="CurveClaim",e[e.HinkalStake=15]="HinkalStake",e[e.HinkalUnstake=16]="HinkalUnstake",e[e.ConvexDeposit=17]="ConvexDeposit",e[e.ConvexWithdraw=18]="ConvexWithdraw",e[e.BeefyDeposit=19]="BeefyDeposit",e[e.BeefyWithdraw=20]="BeefyWithdraw",e[e.Fund=21]="Fund",e[e.Receive=22]="Receive",e))(m||{});exports.TransactionAction=m;exports.TransactionStatus=u;exports.emptyDecodedTx=p;

package/types/transactions.types.d.ts

@@ -52,4 +52,35 @@ export type OnChainUtxo<AmountType = bigint> = {
     tokenId: number;
 };
 export declare const emptyDecodedTx: DecodedTx;
+export declare enum TransactionStatus {
+    Confirmed = 0,
+    Failed = 1,
+    Loading = 2,
+    NotStarted = 3
+}
+export declare enum TransactionAction {
+    None = 0,
+    Deposit = 1,
+    Mint = 2,
+    PoolAdd = 3,
+    PoolRemove = 4,
+    Redeem = 5,
+    Swap = 6,
+    Transfer = 7,
+    Withdraw = 8,
+    Send = 9,
+    CurveDeposit = 10,
+    CurveWithdraw = 11,
+    CurveStake = 12,
+    CurveUnstake = 13,
+    CurveClaim = 14,
+    HinkalStake = 15,
+    HinkalUnstake = 16,
+    ConvexDeposit = 17,
+    ConvexWithdraw = 18,
+    BeefyDeposit = 19,
+    BeefyWithdraw = 20,
+    Fund = 21,
+    Receive = 22
+}
 export {};

package/types/transactions.types.mjs

@@ -1,5 +1,5 @@
-import { BigNumber as t } from "ethers";
-const o = t.from(0), r = {
+import { BigNumber as d } from "ethers";
+const m = d.from(0), k = {
   blockNumber: 0,
   timeStamp: 0,
   methodId: "",
@@ -7,8 +7,8 @@ const o = t.from(0), r = {
   decodedInput: {
     erc20TokenAddresses: [],
     amountChanges: [],
-    flatFees: [0n, 0n].map((e) => t.from(e)),
-    externalActionId: o,
+    flatFees: [0n, 0n].map((e) => d.from(e)),
+    externalActionId: m,
     externalActionMetadata: "",
     encryptedOutputs: [],
     hookData: {
@@ -31,6 +31,9 @@ const o = t.from(0), r = {
   isError: "",
   status: ""
 };
+var p = /* @__PURE__ */ ((e) => (e[e.Confirmed = 0] = "Confirmed", e[e.Failed = 1] = "Failed", e[e.Loading = 2] = "Loading", e[e.NotStarted = 3] = "NotStarted", e))(p || {}), C = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Deposit = 1] = "Deposit", e[e.Mint = 2] = "Mint", e[e.PoolAdd = 3] = "PoolAdd", e[e.PoolRemove = 4] = "PoolRemove", e[e.Redeem = 5] = "Redeem", e[e.Swap = 6] = "Swap", e[e.Transfer = 7] = "Transfer", e[e.Withdraw = 8] = "Withdraw", e[e.Send = 9] = "Send", e[e.CurveDeposit = 10] = "CurveDeposit", e[e.CurveWithdraw = 11] = "CurveWithdraw", e[e.CurveStake = 12] = "CurveStake", e[e.CurveUnstake = 13] = "CurveUnstake", e[e.CurveClaim = 14] = "CurveClaim", e[e.HinkalStake = 15] = "HinkalStake", e[e.HinkalUnstake = 16] = "HinkalUnstake", e[e.ConvexDeposit = 17] = "ConvexDeposit", e[e.ConvexWithdraw = 18] = "ConvexWithdraw", e[e.BeefyDeposit = 19] = "BeefyDeposit", e[e.BeefyWithdraw = 20] = "BeefyWithdraw", e[e.Fund = 21] = "Fund", e[e.Receive = 22] = "Receive", e))(C || {});
 export {
-  r as emptyDecodedTx
+  C as TransactionAction,
+  p as TransactionStatus,
+  k as emptyDecodedTx
 };

package/types/wc.types.d.ts

@@ -0,0 +1,89 @@
+import { BuildApprovedNamespacesParams } from '@walletconnect/utils';
+export interface VerifyContextOptions {
+    verified: {
+        origin: string;
+        validation: string;
+        verifyUrl: string;
+    };
+}
+export type WCSessionProposalOptions = {
+    id: number;
+    params: BuildApprovedNamespacesParams['proposal'];
+    verifyContext: VerifyContextOptions;
+};
+export type WCSessionRequestOptions = {
+    id: number;
+    topic: string;
+    params: {
+        chainId: string;
+        request: {
+            method: string;
+            params: unknown[];
+        };
+    };
+    verifyContext: VerifyContextOptions;
+};
+export interface TxParametersBase {
+    from: string;
+    to: string;
+    gas?: string;
+    gasPrice?: string;
+    value: string;
+    data?: string;
+}
+export interface WCTransactionParameters<T = number> extends TxParametersBase {
+    chainId: T;
+}
+type BaseNamespace = {
+    chains?: string[];
+    accounts: string[];
+    methods: string[];
+    events: string[];
+};
+type Namespaces = Record<string, BaseNamespace>;
+export type WCSession = {
+    topic: string;
+    pairingTopic: string;
+    acknowledged: boolean;
+    controller: string;
+    self: {
+        publicKey: string;
+    };
+    peer: {
+        publicKey: string;
+        metadata: {
+            name: string;
+            description: string;
+            url: string;
+            icons: string[];
+        };
+    };
+    namespaces: Namespaces;
+};
+export interface WCErrorResponse {
+    id: number;
+    error: {
+        code: number;
+        message: string;
+    };
+    jsonrpc: string;
+}
+export interface WCSuccessResponse {
+    id: number;
+    result: string | null;
+    jsonrpc: string;
+}
+export type WCResponse = WCErrorResponse | WCSuccessResponse;
+export interface WCCofirmationDetails {
+    title: string;
+    subTitle?: string;
+    disclaimer?: string;
+    showConnectWith?: boolean;
+    confirmBtnLabel?: string;
+}
+export type AppMetaData = {
+    url?: string;
+    icon: string;
+    name: string;
+};
+export {};

package/types/with-id.types.d.ts

@@ -0,0 +1,3 @@
+export type WithId<T> = T & {
+    id: number;
+};

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.cjs

@@ -1 +1 @@
-"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/snarkjsWorkerLauncher-C4z-FxO0.js").href:new URL("../../assets/snarkjsWorkerLauncher-C4z-FxO0.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;
+"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/snarkjsWorkerLauncher-DaadjbPk.js").href:new URL("../../assets/snarkjsWorkerLauncher-DaadjbPk.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.mjs

@@ -1,4 +1,4 @@
-const r = "" + new URL("../../assets/snarkjsWorkerLauncher-C4z-FxO0.js", import.meta.url).href;
+const r = "" + new URL("../../assets/snarkjsWorkerLauncher-DaadjbPk.js", import.meta.url).href;
 export {
   r as default
 };

package/webworker/snarkjsWorker/snarkjsWorkerLogic.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const $=require("../workerProxy.cjs"),n=require("../../constants/vite.constants.cjs"),O=require("snarkjs"),v=require("axios");function F(e){const i=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const t in e)if(t!=="default"){const s=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(i,t,s.get?s:{enumerable:!0,get:()=>e[t]})}}return i.default=e,Object.freeze(i)}const p=F(O),c=new $.WorkerProxy,y=async e=>new Uint8Array((await v.get(e,{responseType:"arraybuffer"})).data),g=async e=>{const{input:i,wasmFilePath:t,zKeyFilePath:s,chainId:b}=e.payload.data,{hostLocation:{origin:l},constants:{isDevelopment:w,chains:{chainIds:k}}}=e.metadata;let a=t,r=s,u,f;const d=a.startsWith("https://");if(n.isNode&&!d){n.isWebpack?(a=`libs/hardhat/test/circuits/${t}`,r=`libs/hardhat/test/circuits/${s}`):!n.isWebpack&&w&&(a=`test/circuits/${t}`,r=`test/circuits/${s}`);const o=require("path");a=o.resolve(a),r=o.resolve(r)}n.isNode&&d?(u=await y(a),f=await y(r)):b===k.localhost&&!n.isNode&&(a=`${l}/${t}`,r=`${l}/${s}`);try{const{proof:o,publicSignals:h}=await p.groth16.fullProve(i,u??a,f??r),P=await p.groth16.exportSolidityCallData(o,h),m=JSON.parse(`[${P}]`);c.postMessageToMainThread({zkCallData:m,proof:o,publicSignals:h})}catch(o){console.log(o)}};c.attachWorkerSideOnMessage(g);exports.default=c;exports.onWorkerMessage=g;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const w=require("../workerProxy.cjs"),i=require("../../constants/vite.constants.cjs"),$=require("snarkjs");function m(t){const s=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(t){for(const e in t)if(e!=="default"){const r=Object.getOwnPropertyDescriptor(t,e);Object.defineProperty(s,e,r.get?r:{enumerable:!0,get:()=>t[e]})}}return s.default=t,Object.freeze(s)}const p=m($),n=new w.WorkerProxy,f=async t=>{try{const{input:s,wasmFilePath:e,zKeyFilePath:r,chainId:g}=t.payload.data,{hostLocation:{origin:c},constants:{isDevelopment:b,chains:{chainIds:k}}}=t.metadata;let o=e,a=r;const l=o.startsWith("https://");if(i.isNode&&!l){i.isWebpack?(o=`libs/hardhat/test/circuits/${e}`,a=`libs/hardhat/test/circuits/${r}`):!i.isWebpack&&b&&(o=`test/circuits/${e}`,a=`test/circuits/${r}`);const h=require("path");o=h.resolve(o),a=h.resolve(a)}i.isNode&&l?process.browser=!0:g===k.localhost&&!i.isNode&&(o=`${c}/${e}`,a=`${c}/${r}`);const{proof:u,publicSignals:d}=await p.groth16.fullProve(s,o,a),y=await p.groth16.exportSolidityCallData(u,d),P=JSON.parse(`[${y}]`);n.postMessageToMainThread({zkCallData:P,proof:u,publicSignals:d})}catch(s){console.error(s),n.postErrorToMainThread(s)}};n.attachWorkerSideOnMessage(f);exports.default=n;exports.onWorkerMessage=f;

package/webworker/snarkjsWorker/snarkjsWorkerLogic.mjs

@@ -1,36 +1,31 @@
-import { WorkerProxy as P } from "../workerProxy.mjs";
-import { isNode as o, isWebpack as p } from "../../constants/vite.constants.mjs";
-import * as u from "snarkjs";
-import b from "axios";
-const m = new P(), y = async (s) => new Uint8Array((await b.get(s, { responseType: "arraybuffer" })).data), x = async (s) => {
-  const { input: d, wasmFilePath: r, zKeyFilePath: i, chainId: w } = s.payload.data, {
-    hostLocation: { origin: l },
-    constants: {
-      isDevelopment: g,
-      chains: { chainIds: $ }
-    }
-  } = s.metadata;
-  let t = r, a = i, n, c;
-  const h = t.startsWith("https://");
-  if (o && !h) {
-    p ? (t = `libs/hardhat/test/circuits/${r}`, a = `libs/hardhat/test/circuits/${i}`) : !p && g && (t = `test/circuits/${r}`, a = `test/circuits/${i}`);
-    const e = require("path");
-    t = e.resolve(t), a = e.resolve(a);
-  }
-  o && h ? (n = await y(t), c = await y(a)) : w === $.localhost && !o && (t = `${l}/${r}`, a = `${l}/${i}`);
+import { WorkerProxy as g } from "../workerProxy.mjs";
+import { isNode as r, isWebpack as u } from "../../constants/vite.constants.mjs";
+import * as f from "snarkjs";
+const i = new g(), P = async (l) => {
   try {
-    const { proof: e, publicSignals: f } = await u.groth16.fullProve(
-      d,
-      n ?? t,
-      c ?? a
-    ), k = await u.groth16.exportSolidityCallData(e, f), F = JSON.parse(`[${k}]`);
-    m.postMessageToMainThread({ zkCallData: F, proof: e, publicSignals: f });
-  } catch (e) {
-    console.log(e);
+    const { input: a, wasmFilePath: e, zKeyFilePath: o, chainId: m } = l.payload.data, {
+      hostLocation: { origin: c },
+      constants: {
+        isDevelopment: $,
+        chains: { chainIds: k }
+      }
+    } = l.metadata;
+    let t = e, s = o;
+    const n = t.startsWith("https://");
+    if (r && !n) {
+      u ? (t = `libs/hardhat/test/circuits/${e}`, s = `libs/hardhat/test/circuits/${o}`) : !u && $ && (t = `test/circuits/${e}`, s = `test/circuits/${o}`);
+      const d = require("path");
+      t = d.resolve(t), s = d.resolve(s);
+    }
+    r && n ? process.browser = !0 : m === k.localhost && !r && (t = `${c}/${e}`, s = `${c}/${o}`);
+    const { proof: h, publicSignals: p } = await f.groth16.fullProve(a, t, s), w = await f.groth16.exportSolidityCallData(h, p), y = JSON.parse(`[${w}]`);
+    i.postMessageToMainThread({ zkCallData: y, proof: h, publicSignals: p });
+  } catch (a) {
+    console.error(a), i.postErrorToMainThread(a);
   }
 };
-m.attachWorkerSideOnMessage(x);
+i.attachWorkerSideOnMessage(P);
 export {
-  m as default,
-  x as onWorkerMessage
+  i as default,
+  P as onWorkerMessage
 };

package/webworker/utxoWorker/utxoWorkerLauncher.cjs

@@ -1 +1 @@
-"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/utxoWorkerLauncher-Dep9IVHI.js").href:new URL("../../assets/utxoWorkerLauncher-Dep9IVHI.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;
+"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/utxoWorkerLauncher-DeyOrJhH.js").href:new URL("../../assets/utxoWorkerLauncher-DeyOrJhH.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;

package/webworker/utxoWorker/utxoWorkerLauncher.mjs

@@ -1,4 +1,4 @@
-const e = "" + new URL("../../assets/utxoWorkerLauncher-Dep9IVHI.js", import.meta.url).href;
+const e = "" + new URL("../../assets/utxoWorkerLauncher-DeyOrJhH.js", import.meta.url).href;
 export {
   e as default
 };

package/webworker/utxoWorker/utxoWorkerLogic.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const f=require("../../crypto/preProcessing.cjs"),d=require("../../data-structures/crypto-keys/keys.cjs"),T=require("../../data-structures/utxo/Utxo.cjs"),y=require("../../data-structures/crypto-keys/encryptDecryptUtxo.cjs"),h=require("../../data-structures/crypto-keys/decodeUTXO.cjs"),k=require("../workerProxy.cjs"),l=require("./utxoWorker.types.cjs"),c=new k.WorkerProxy,p=async({data:e})=>{const{utxos:t,nullifiers:s}=e,o=t.filter(r=>{const i=new T.Utxo(r);return!s.has(i.getNullifier())});c.postMessageToMainThread(o)},U=async({data:e})=>{const t=new d.UserKeys(e.signature),s=t.getShieldedPrivateKey(),o=e.encryptedOutputs.map((r,i)=>{try{return r.isPositive?y.decryptUtxoConstructorArgs(Buffer.from(r.value.slice(2),"hex"),t):h.decodeUtxoConstructorArgs(r.value,s)}catch{return}}).filter(r=>r!==void 0);c.postMessageToMainThread(o)},x=async({data:e})=>{const t=new d.UserKeys(e.signature),s=[],{encryptedOutputs:o}=e;let{lastOutput:r}=e;const i=t.getShieldedPrivateKey();for(let u=0;u<o.length;u+=1){const a=o[u];if(r=a.value,a.isPositive)try{const n=y.decryptUtxo(Buffer.from(r.slice(2),"hex"),t);if(!n.erc20TokenAddress||!n.amount||!n.stealthAddress)throw Error("bruh");s.push(a)}catch{}else try{h.checkUtxoSignature(r,i)&&s.push(a)}catch{}}c.postMessageToMainThread({additionalEncryptedOutputs:s,lastOutput:r})},g=async e=>{await f.preProcessing();const{type:t}=e.payload;switch(t){case l.UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER:p(e.payload);return;case l.UtxoWorkerActionType.BUILD_UTXOS:U(e.payload);return;case l.UtxoWorkerActionType.DECIPHER_OUTPUTS:x(e.payload);return;default:throw Error(`Unknown worker message type ${t}`)}};c.attachWorkerSideOnMessage(g);exports.default=c;exports.handleBuildUtxosMessage=U;exports.handleDecipherMessage=x;exports.handleFilterUtxosWithNullifier=p;exports.onWorkerMessage=g;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const f=require("../../crypto/preProcessing.cjs"),a=require("../../data-structures/crypto-keys/keys.cjs"),T=require("../../data-structures/utxo/Utxo.cjs"),h=require("../../data-structures/crypto-keys/encryptDecryptUtxo.cjs"),y=require("../../data-structures/crypto-keys/decodeUTXO.cjs"),k=require("../workerProxy.cjs"),d=require("./utxoWorker.types.cjs"),c=new k.WorkerProxy,p=async({data:e})=>{const{utxos:r,nullifiers:s}=e,o=r.filter(t=>{const u=new T.Utxo(t);return!s.has(u.getNullifier())});c.postMessageToMainThread({utxoConstructors:o,stealthPairCache:a.stealthPairCacheDevice.serialize(),stealthAddressCache:a.stealthAddressCacheDevice.serialize()})},U=async({data:e})=>{const r=new a.UserKeys(e.signature),s=r.getShieldedPrivateKey(),o=e.encryptedOutputs.map(t=>{try{return t.isPositive?h.decryptUtxoConstructorArgs(Buffer.from(t.value.slice(2),"hex"),r):y.decodeUtxoConstructorArgs(t.value,s)}catch{return}}).filter(t=>t!==void 0&&t.amount!==0n);c.postMessageToMainThread(o)},x=async({data:e})=>{const r=new a.UserKeys(e.signature),s=[],{encryptedOutputs:o}=e;let{lastOutput:t}=e;const u=r.getShieldedPrivateKey();for(let l=0;l<o.length;l+=1){const n=o[l];if(t=n.value,n.isPositive)try{const i=h.decryptUtxo(Buffer.from(t.slice(2),"hex"),r);if(!i.erc20TokenAddress||!i.amount||!i.stealthAddress)throw Error("bruh");s.push(n)}catch{}else try{y.checkUtxoSignature(t,u)&&s.push(n)}catch{}}c.postMessageToMainThread({additionalEncryptedOutputs:s,lastOutput:t})},g=async e=>{try{await f.preProcessing();const{type:r}=e.payload;switch(r){case d.UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER:await p(e.payload);return;case d.UtxoWorkerActionType.BUILD_UTXOS:await U(e.payload);return;case d.UtxoWorkerActionType.DECIPHER_OUTPUTS:await x(e.payload);return;default:throw Error(`Unknown worker message type ${r}`)}}catch(r){console.error(r),c.postErrorToMainThread(r)}};c.attachWorkerSideOnMessage(g);exports.default=c;exports.handleBuildUtxosMessage=U;exports.handleDecipherMessage=x;exports.handleFilterUtxosWithNullifier=p;exports.onWorkerMessage=g;