@chorus-one/polygon 1.0.0

package/.mocharc.json

@@ -0,0 +1,6 @@
+{
+  "require": ["tsx"],
+  "extensions": ["ts"],
+  "timeout": 10000,
+  "reporter": "spec"
+}

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Chorus One AG
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,233 @@
+# Chorus One SDK: Polygon
+
+All-in-one toolkit for building staking dApps on Polygon PoS network.
+
+## Documentation
+
+For detailed instructions on how to set up and use the Chorus One SDK for Polygon staking, please visit our [main documentation](https://chorus-one.gitbook.io/sdk/build-your-staking-dapp/polygon/overview).
+
+## Installation
+
+In the project's root directory, run the following command:
+
+```bash
+npm install @chorus-one/polygon
+```
+
+## Usage
+
+Here is a basic example of how to use the Chorus One SDK to build, sign, and broadcast staking transactions on Polygon PoS.
+
+### Configuration
+
+```javascript
+import { PolygonStaker } from '@chorus-one/polygon'
+
+const staker = new PolygonStaker({
+  network: 'mainnet', // 'mainnet' (Ethereum L1) or 'testnet' (Sepolia L1)
+  rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY' // Optional: uses viem's default if not provided
+})
+```
+
+### Querying Staking Information
+
+```javascript
+const delegatorAddress = '0xYourAddress'
+const validatorShareAddress = '0xValidatorShareContract'
+
+// Get staking info (balance, shares, exchange rate)
+const stake = await staker.getStake({ delegatorAddress, validatorShareAddress })
+console.log('Staked Balance:', stake.balance, 'POL')
+console.log('Shares:', stake.shares)
+console.log('Exchange Rate:', stake.exchangeRate)
+
+// Get pending rewards
+const rewards = await staker.getLiquidRewards({ delegatorAddress, validatorShareAddress })
+console.log('Pending Rewards:', rewards, 'POL')
+
+// Get POL allowance for StakeManager
+const allowance = await staker.getAllowance(delegatorAddress)
+console.log('Current Allowance:', allowance, 'POL')
+
+// Get unbond info (for pending unstakes)
+const unbondNonce = await staker.getUnbondNonce({ delegatorAddress, validatorShareAddress })
+if (unbondNonce > 0n) {
+  const unbond = await staker.getUnbond({ delegatorAddress, validatorShareAddress, unbondNonce })
+  console.log('Amount:', unbond.amount, 'POL')
+  console.log('Withdrawable:', unbond.isWithdrawable)
+  console.log('Shares:', unbond.shares)
+  console.log('Withdraw Epoch:', unbond.withdrawEpoch)
+
+  // Or fetch multiple unbonds efficiently in a single RPC call
+  const unbonds = await staker.getUnbonds({
+    delegatorAddress,
+    validatorShareAddress,
+    unbondNonces: [1n, 2n, 3n]
+  })
+  unbonds.forEach((u, i) => console.log(`Unbond ${i + 1}: ${u.amount} POL, withdrawable: ${u.isWithdrawable}`))
+}
+
+// Get current epoch and withdrawal delay
+const epoch = await staker.getEpoch()
+const withdrawalDelay = await staker.getWithdrawalDelay()
+console.log('Current Epoch:', epoch)
+console.log('Withdrawal Delay:', withdrawalDelay, 'epochs')
+```
+
+### Approve POL Tokens
+
+Before staking, you must approve the StakeManager contract to spend your POL tokens:
+
+```javascript
+import { FireblocksSigner } from '@chorus-one/signer-fireblocks'
+
+const signer = new FireblocksSigner({...})
+await signer.init()
+
+const { tx: approveTx } = await staker.buildApproveTx({
+  amount: '1000' // Amount in POL, or 'max' for unlimited approval
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx: approveTx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Stake (Delegate) to Validator
+
+Delegate POL tokens to a validator via their ValidatorShare contract:
+
+```javascript
+const { tx } = await staker.buildStakeTx({
+  delegatorAddress,
+  validatorShareAddress,
+  amount: '1000', // Amount in POL
+  slippageBps: 50 // 0.5% slippage tolerance (auto-calculates minSharesToMint)
+  // Or use minSharesToMint directly: minSharesToMint: 999n * 10n ** 18n
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Unstake (Unbond) from Validator
+
+Create an unbond request to unstake POL tokens. After the unbonding period (~80 epochs, approximately 3-4 days), call withdraw to claim funds:
+
+```javascript
+const { tx } = await staker.buildUnstakeTx({
+  delegatorAddress,
+  validatorShareAddress,
+  amount: '500', // Amount in POL
+  slippageBps: 50 // 0.5% slippage tolerance (auto-calculates maximumSharesToBurn)
+  // Or use maximumSharesToBurn directly: maximumSharesToBurn: 501n * 10n ** 18n
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Withdraw Unstaked Tokens
+
+Claim unstaked POL tokens after the unbonding period has elapsed. Each unstake creates a separate unbond with its own nonce:
+
+```javascript
+// Get the unbond nonce for the unstake you want to withdraw
+const unbondNonce = await staker.getUnbondNonce({ delegatorAddress, validatorShareAddress })
+
+const { tx } = await staker.buildWithdrawTx({
+  delegatorAddress,
+  validatorShareAddress,
+  unbondNonce
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Claim Rewards
+
+Claim accumulated delegation rewards and send them to your wallet:
+
+```javascript
+const { tx } = await staker.buildClaimRewardsTx({
+  delegatorAddress,
+  validatorShareAddress
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Compound (Restake) Rewards
+
+Restake accumulated rewards back into the validator, increasing your delegation without new tokens:
+
+```javascript
+const { tx } = await staker.buildCompoundTx({
+  delegatorAddress,
+  validatorShareAddress
+})
+
+const { signedTx } = await staker.sign({
+  signer,
+  signerAddress: delegatorAddress,
+  tx
+})
+
+const { txHash } = await staker.broadcast({ signedTx })
+```
+
+### Tracking Transaction Status
+
+```javascript
+const { status, receipt } = await staker.getTxStatus({ txHash })
+
+console.log(status) // 'success', 'failure', or 'unknown'
+```
+
+## Key Features
+
+- **Ethereum L1 Based**: Polygon PoS staking operates via ValidatorShare contracts deployed on Ethereum mainnet (or Sepolia for testnet)
+- **POL Token Staking**: Stake the native POL token (formerly MATIC) to validators
+- **Human-Readable Amounts**: Pass token amounts as strings (e.g., '1.5'), conversion to wei is handled automatically
+- **Slippage Protection**: Stake and unstake operations support `slippageBps` (basis points) for automatic slippage calculation, or manual `minSharesToMint`/`maximumSharesToBurn` parameters
+- **Query Methods**: Read stake balances, rewards, allowances, unbond status (with POL amount and withdrawability), and epoch information
+- **Rewards Management**: Claim rewards to wallet or compound them back into your delegation
+
+## Important Notes
+
+- **Token Approval**: You must approve the StakeManager contract to spend POL tokens before staking. Use `buildApproveTx()` to create the approval transaction.
+- **Unbonding Period**: After unstaking, there is an unbonding period of ~80 epochs (approximately 3-4 days) before tokens can be withdrawn.
+- **Unbond Nonces**: Each unstake operation creates a separate unbond request with an incrementing nonce. Withdrawals must be done per-nonce. Claimed unbonds are deleted, but the nonce counter never decrements. Use `getUnbonds()` to efficiently fetch multiple unbond requests in a single RPC call.
+- **Referrer Tracking**: Transaction builders that support referrer tracking (stake, unstake, claim rewards, compound) append a tracking marker to the transaction calldata. By default, `sdk-chorusone-staking` is used as the referrer. You can provide a custom referrer via the `referrer` parameter.
+- **Exchange Rate**: The exchange rate between shares and POL may fluctuate. Use `slippageBps` for automatic slippage protection, or specify `minSharesToMint`/`maximumSharesToBurn` directly. Foundation validators (ID < 8) use different precision than others.
+- **Validator Share Contracts**: Each validator has their own ValidatorShare contract address. You must specify the correct contract address for the validator you want to delegate to.
+
+## License
+
+The Chorus One SDK is licensed under the Apache 2.0 License. For more detailed information, please refer to the [LICENSE](./LICENSE) file in the repository.

package/dist/cjs/constants.d.ts

@@ -0,0 +1,187 @@
+import type { Address } from 'viem';
+export type PolygonNetworks = 'mainnet' | 'testnet';
+export interface NetworkContracts {
+    stakeManagerAddress: Address;
+    stakingTokenAddress: Address;
+}
+/** Contract addresses per network (mainnet = Ethereum L1, testnet = Sepolia L1) */
+export declare const NETWORK_CONTRACTS: Record<PolygonNetworks, NetworkContracts>;
+/** Chorus One Polygon ValidatorShare contract addresses */
+export declare const CHORUS_ONE_POLYGON_VALIDATORS: {
+    readonly mainnet: `0x${string}`;
+    readonly testnet: `0x${string}`;
+};
+export declare const VALIDATOR_SHARE_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "buyVoucherPOL";
+    readonly inputs: readonly [{
+        readonly name: "_amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "_minSharesToMint";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amountToDeposit";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "sellVoucher_newPOL";
+    readonly inputs: readonly [{
+        readonly name: "claimAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "maximumSharesToBurn";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "unstakeClaimTokens_newPOL";
+    readonly inputs: readonly [{
+        readonly name: "unbondNonce";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "withdrawRewardsPOL";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "restakePOL";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "amountRestaked";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "liquidReward";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "getTotalStake";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "unbondNonces";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "unbonds_new";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "shares";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "withdrawEpoch";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getLiquidRewards";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "validatorId";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "withdrawExchangeRate";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];
+export declare const EXCHANGE_RATE_PRECISION = 100n;
+export declare const EXCHANGE_RATE_HIGH_PRECISION: bigint;
+export declare const STAKE_MANAGER_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "epoch";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "withdrawalDelay";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];

package/dist/cjs/constants.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STAKE_MANAGER_ABI = exports.EXCHANGE_RATE_HIGH_PRECISION = exports.EXCHANGE_RATE_PRECISION = exports.VALIDATOR_SHARE_ABI = exports.CHORUS_ONE_POLYGON_VALIDATORS = exports.NETWORK_CONTRACTS = void 0;
+/** Contract addresses per network (mainnet = Ethereum L1, testnet = Sepolia L1) */
+// Reference: https://docs.polygon.technology/pos/reference/rpc-endpoints/
+exports.NETWORK_CONTRACTS = {
+    mainnet: {
+        stakeManagerAddress: '0x5e3Ef299fDDf15eAa0432E6e66473ace8c13D908',
+        stakingTokenAddress: '0x455e53CBB86018Ac2B8092FdCd39d8444aFFC3F6'
+    },
+    testnet: {
+        stakeManagerAddress: '0x4AE8f648B1Ec892B6cc68C89cc088583964d08bE',
+        stakingTokenAddress: '0x44499312f493F62f2DFd3C6435Ca3603EbFCeeBa'
+    }
+};
+/** Chorus One Polygon ValidatorShare contract addresses */
+// Reference mainnet: https://staking.polygon.technology/validators/106
+// Reference testnet (Random Validator): https://staking.polygon.technology/validators/31
+exports.CHORUS_ONE_POLYGON_VALIDATORS = {
+    mainnet: '0xD9E6987D77bf2c6d0647b8181fd68A259f838C36',
+    testnet: '0x91344055cb0511b3aa36c561d741ee356b95f1c9'
+};
+// Reference: https://github.com/0xPolygon/pos-contracts/blob/main/contracts/staking/validatorShare/ValidatorShare.sol
+exports.VALIDATOR_SHARE_ABI = [
+    {
+        type: 'function',
+        name: 'buyVoucherPOL',
+        inputs: [
+            { name: '_amount', type: 'uint256', internalType: 'uint256' },
+            { name: '_minSharesToMint', type: 'uint256', internalType: 'uint256' }
+        ],
+        outputs: [{ name: 'amountToDeposit', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'nonpayable'
+    },
+    {
+        type: 'function',
+        name: 'sellVoucher_newPOL',
+        inputs: [
+            { name: 'claimAmount', type: 'uint256', internalType: 'uint256' },
+            { name: 'maximumSharesToBurn', type: 'uint256', internalType: 'uint256' }
+        ],
+        outputs: [],
+        stateMutability: 'nonpayable'
+    },
+    {
+        type: 'function',
+        name: 'unstakeClaimTokens_newPOL',
+        inputs: [{ name: 'unbondNonce', type: 'uint256', internalType: 'uint256' }],
+        outputs: [],
+        stateMutability: 'nonpayable'
+    },
+    {
+        type: 'function',
+        name: 'withdrawRewardsPOL',
+        inputs: [],
+        outputs: [],
+        stateMutability: 'nonpayable'
+    },
+    {
+        type: 'function',
+        name: 'restakePOL',
+        inputs: [],
+        outputs: [
+            { name: 'amountRestaked', type: 'uint256', internalType: 'uint256' },
+            { name: 'liquidReward', type: 'uint256', internalType: 'uint256' }
+        ],
+        stateMutability: 'nonpayable'
+    },
+    {
+        type: 'function',
+        name: 'getTotalStake',
+        inputs: [{ name: 'user', type: 'address', internalType: 'address' }],
+        outputs: [
+            { name: '', type: 'uint256', internalType: 'uint256' },
+            { name: '', type: 'uint256', internalType: 'uint256' }
+        ],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'unbondNonces',
+        inputs: [{ name: '', type: 'address', internalType: 'address' }],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'unbonds_new',
+        inputs: [
+            { name: '', type: 'address', internalType: 'address' },
+            { name: '', type: 'uint256', internalType: 'uint256' }
+        ],
+        outputs: [
+            { name: 'shares', type: 'uint256', internalType: 'uint256' },
+            { name: 'withdrawEpoch', type: 'uint256', internalType: 'uint256' }
+        ],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'getLiquidRewards',
+        inputs: [{ name: 'user', type: 'address', internalType: 'address' }],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'validatorId',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'withdrawExchangeRate',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    }
+];
+// Exchange rate precision constants from the ValidatorShare contract
+// Reference: https://github.com/0xPolygon/pos-contracts/blob/main/contracts/staking/validatorShare/ValidatorShare.sol
+exports.EXCHANGE_RATE_PRECISION = 100n;
+exports.EXCHANGE_RATE_HIGH_PRECISION = 10n ** 29n;
+// Reference: https://github.com/0xPolygon/pos-contracts/blob/main/contracts/staking/stakeManager/StakeManager.sol
+exports.STAKE_MANAGER_ABI = [
+    {
+        type: 'function',
+        name: 'epoch',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    },
+    {
+        type: 'function',
+        name: 'withdrawalDelay',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+        stateMutability: 'view'
+    }
+];

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { PolygonStaker } from './staker';
+export { PolygonNetworkConfig, Transaction, PolygonTxStatus, StakeInfo, UnbondInfo } from './types';
+export { NETWORK_CONTRACTS, CHORUS_ONE_POLYGON_VALIDATORS, VALIDATOR_SHARE_ABI, STAKE_MANAGER_ABI, EXCHANGE_RATE_PRECISION, EXCHANGE_RATE_HIGH_PRECISION } from './constants';
+export type { PolygonNetworks, NetworkContracts } from './constants';

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCHANGE_RATE_HIGH_PRECISION = exports.EXCHANGE_RATE_PRECISION = exports.STAKE_MANAGER_ABI = exports.VALIDATOR_SHARE_ABI = exports.CHORUS_ONE_POLYGON_VALIDATORS = exports.NETWORK_CONTRACTS = exports.PolygonStaker = void 0;
+var staker_1 = require("./staker");
+Object.defineProperty(exports, "PolygonStaker", { enumerable: true, get: function () { return staker_1.PolygonStaker; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "NETWORK_CONTRACTS", { enumerable: true, get: function () { return constants_1.NETWORK_CONTRACTS; } });
+Object.defineProperty(exports, "CHORUS_ONE_POLYGON_VALIDATORS", { enumerable: true, get: function () { return constants_1.CHORUS_ONE_POLYGON_VALIDATORS; } });
+Object.defineProperty(exports, "VALIDATOR_SHARE_ABI", { enumerable: true, get: function () { return constants_1.VALIDATOR_SHARE_ABI; } });
+Object.defineProperty(exports, "STAKE_MANAGER_ABI", { enumerable: true, get: function () { return constants_1.STAKE_MANAGER_ABI; } });
+Object.defineProperty(exports, "EXCHANGE_RATE_PRECISION", { enumerable: true, get: function () { return constants_1.EXCHANGE_RATE_PRECISION; } });
+Object.defineProperty(exports, "EXCHANGE_RATE_HIGH_PRECISION", { enumerable: true, get: function () { return constants_1.EXCHANGE_RATE_HIGH_PRECISION; } });

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/referrer.d.ts

@@ -0,0 +1,2 @@
+import type { Hex } from 'viem';
+export declare const appendReferrerTracking: (data: Hex, referrer?: string) => Hex;

package/dist/cjs/referrer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendReferrerTracking = void 0;
+const viem_1 = require("viem");
+const DEFAULT_REFERRER = 'sdk-chorusone-staking';
+const REFERRER_MARKER = 'c1c1';
+const encodeReferrer = (referrer) => {
+    const hash = (0, viem_1.keccak256)((0, viem_1.toHex)(referrer));
+    return `0x${REFERRER_MARKER}${hash.slice(2, 8)}`;
+};
+const appendReferrerTracking = (data, referrer) => {
+    const encoded = encodeReferrer(referrer ?? DEFAULT_REFERRER);
+    return `${data}${encoded.slice(2)}`;
+};
+exports.appendReferrerTracking = appendReferrerTracking;