npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2025 – Pkg Stats / Ryan Hefner

@hinkal/common

v0.2.9

Published

Hinkal is middleware and a set of smart contracts on EVM chains that use ZK-proofs and stealth addresses to enable compliant and private transactions on major dApps. Users can privately store assets and transact on platforms such as Uniswap, Pendle, Lido,

Downloads

1,435

Readme

Hinkal SDK

Hinkal is middleware and a set of smart contracts on EVM chains that use ZK-proofs and stealth addresses to enable compliant and private transactions on major dApps. Users can privately store assets and transact on platforms such as Uniswap, Pendle, Lido, Curve, and others.

This SDK enables users to perform arbitrary smart contract interactions privately.

Installation

Using npm:

npm install @hinkal/common

Or, yarn:

yarn add @hinkal/common

Usage

Initialization

To get started with Hinkal, initialize it based on the Web3 connection library you’re using:

ethers.js:

import { prepareEthersHinkal } from '@hinkal/common/providers/prepareEthersHinkal';
// signer: ethers.Signer
const hinkal = await prepareEthersHinkal(signer);

wagmi:

import { prepareWagmiHinkal } from '@hinkal/common/providers/prepareWagmiHinkal';
// connector: wagmi.Connector
// config: wagmi.Config
const hinkal = await prepareWagmiHinkal(connector, config);

Shielded balance

Once the Hinkal object is initialized, shielded balances become accessible and can be calculated as needed:

const balances = await hinkal.getBalances();

Depositing funds to the shielded balance

A user can deposit funds to their shielded address using:

function deposit(erc20addresses: string[], amountChanges: bigint[]): Promise<TransactionObject>;

where erc20Addresses is an array of token addresses, and amountChanges represents the token amounts for the deposit.

Interacting with smart contracts privately

After a user’s shielded balance is updated, they can perform any smart contract interaction privately using:

function actionPrivateWallet(
  erc20Addresses: string[],
  amountChanges: bigint[],
  onChainCreation: boolean[],
  ops: string[],
): Promise<TransactionObject>;

where onChainCreation indicates the amounts of tokens that are uncertain before the transaction is executed on-chain. The ops array contains encoded user operations.

User operations

To generate user operations (ops) you will need the emporiumOp function.

import {emporiumOp} from "@hinkal/common";

The function accepts the following arguments:

  1. endpoint (required) - target address or contract instance (with address). The contract instance will be used to properly encode the call function, if any, in the custom operation.
  2. func (optional) - the name of the function to be called on the target address.
  3. args (optional) - arguments of the function to be called on the target address.
  4. invokeWallet (optional) - bool flag that determines the type of transaction. There are two types: stateful and stateless interaction. The default is false (stateless).
  5. value (optional) - the amount of native currency to transfer to the target address.

The emporiumOp function will generate data for subsequent calls, supporting both stateful interaction (with state preservation) and stateless interaction (without state preservation). This is determined by the invokeWallet flag.

To execute on a smart contract, the user operation will be received in the following format:

(address endpoint, bool invokeWallet, uint256 value, bytes data)

This will make it possible to make that kind of call:

(bool success, bytes memory err) = endpoint.call{value: value}(data);
Stateless and stateful

The best way to demonstrate how this works is with an example.

Stateless interaction

Let's say we need to exchange USDC for ETH using DEX.

const operations = [
  emporiumOp(usdcContractInstance, 'approve', [swapRouterAddress, amountIn]),
  emporiumOp(swapRouterContractInstance, 'exactInputSingle', [swapSingleParams]),
  emporiumOp(wethContractInstance, 'withdraw', [amountOut]),
];

To perform a DEX swap, DEX does not need to know historical data about the calling party (e.g. when and what swaps have been performed from this account in the past). It only needs the current token balance for the exchange.

In this case it will be stateless interaction, so there is no need to change the default value of the invokeWallet flag.

Stateful interaction

Another example is when the protocol with which an account interacts needs to know what actions this account has done before, for example, to gain rewards. In this case, some account state will be required.

Let's imagine that you already have Curve LP tokens and need to make a stake.

const operations = [
  emporiumOp(lpTokenInstance, 'approve', [gaugeAddressInstance, amount]), // without flag, because is's stateless interaction
  emporiumOp(gaugeAddressInstance, 'deposit', [amount, invokeWalletAddress], true), // with flag, because it's stateful interaction
];

As you can see, in this case approve is a stateless interaction, but deposit is a stateful interaction, because under the hood Curve will record this address and timestamp in order to calculate the checkpoint correctly in the future.

Access Tokens

Before interacting with Hinkal smart contracts, users need to mint an access token after passing compliance checks.

To check whether a user already has an access token, use the checkAccessToken function:

function checkAccessToken(): Promise<boolean>;

If the user does not have an access token, they must use one of the compliance providers to pass the check. To view the available providers:

function getSupportedPassportLinks(): string[];

After passing the compliance check, the user can mint an access token using:

const { signatureData } = await hinkal.getAPI().getAccessTokenSignature(chainId, ethereumAddress, accessKey);
await mintAccessToken(this, signatureData);

References

Application: Hinkal Docs: Hinkal Documentation