Splits

https://docs.splits.org/
Admin
Splits is a set of composable, open-source, and audited smart contracts designed to manage onchain...
Tokens:47,903
Snippets:211
Trust Score:7.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Splits React SDK

Source: https://docs.splits.org/react

Install the Splits React SDK package using either yarn or npm.

```bash
yarn add @0xsplits/splits-sdk-react
```

```bash
npm install @0xsplits/splits-sdk-react
```

--------------------------------

### Swapper Integration Example (JavaScript)

Source: https://docs.splits.org/core/swapper

This example demonstrates how to interact with the Swapper contract using JavaScript, likely through a library like ethers.js. It shows how to initiate a flash swap by providing the necessary token, amount, and integrator details.

```JavaScript
const swapperAddress = "0x..."; // Swapper contract address
const swapperAbi = [...]; // Swapper contract ABI
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
const swapperContract = new ethers.Contract(swapperAddress, swapperAbi, signer);

async function performFlashSwap() {
  const tokenToSwap = "0x..."; // Address of the token to swap
  const amountToSwap = ethers.utils.parseEther("1"); // Amount to swap
  const integratorAddress = "0x..."; // Address of the integrator
  const userData = "0x"; // Optional user data

  try {
    const tx = await swapperContract.flash(tokenToSwap, amountToSwap, integratorAddress, userData, {
      value: ethers.utils.parseEther("0.001") // Example ETH value if needed
    });
    await tx.wait();
    console.log("Flash swap successful!");
  } catch (error) {
    console.error("Flash swap failed:", error);
  }
}
```

--------------------------------

### SplitV2 SDK Usage Example

Source: https://docs.splits.org/core/split-v2

Provides an example of how to interact with SplitV2 contracts using its SDK. This typically involves creating splits, distributing funds, and managing recipients.

```JavaScript
import { SplitsSDK } from '@0xsplits/splits-sdk';

// Initialize the SDK (replace with your provider and chain ID)
const sdk = new SplitsSDK(window.ethereum, 1); // Example for Ethereum Mainnet

async function createAndDistribute() {
    const recipientAddresses = ['0x...', '0x...'];
    const recipientShares = [50, 50]; // Represents percentages

    // Create a new Split (e.g., PullSplit)
    const createTx = await sdk.createSplit({
        // Specify split type, e.g., 'pull'
        splitType: 'pull',
        // Provide recipient addresses and their shares
        recipients: recipientAddresses,
        shares: recipientShares,
        // Optionally specify a controller or metadata
    });

    console.log('Transaction hash for creating split:', createTx.hash);

    // Wait for the transaction to be mined
    await createTx.wait();

    const splitAddress = await sdk.getSplitAddress(createTx.hash); // Get the address of the created split

    // Distribute funds (e.g., ETH)
    const distributeTx = await sdk.distribute({ 
        splitAddress: splitAddress,
        // Specify token address (address(0) for ETH)
        tokenAddress: '0x0000000000000000000000000000000000000000',
        // Amount to distribute
        amount: '1000000000000000000' // 1 ETH in wei
    });

    console.log('Transaction hash for distributing funds:', distributeTx.hash);
}

createAndDistribute().catch(console.error);

```

--------------------------------

### Vesting SDK Example (JavaScript)

Source: https://docs.splits.org/core/vesting

This example demonstrates how to interact with the Vesting contract using a JavaScript SDK. It would typically involve setting up a contract instance and calling methods to manage vesting streams or release tokens.

```JavaScript
const { ethers } = require("ethers");
const { Vesting } = require("@splits/splits-sdk"); // Assuming SDK path

async function exampleVestingInteraction(signer) {
    const vestingAddress = "0x..."; // Replace with actual Vesting contract address
    const vestingContract = Vesting.attach(vestingAddress, signer);

    // Example: Releasing vested tokens for a specific token
    // const tokenAddress = "0x..."; // Replace with actual token address
    // try {
    //     const tx = await vestingContract.releaseVestedTokens(tokenAddress);
    //     await tx.wait();
    //     console.log("Vested tokens released successfully.");
    // } catch (error) {
    //     console.error("Error releasing vested tokens:", error);
    // }
}

// Usage example:
// const provider = new ethers.providers.JsonRpcProvider("YOUR_RPC_URL");
// const signer = provider.getSigner();
// exampleVestingInteraction(signer);
```

--------------------------------

### Waterfall Example Usage

Source: https://docs.splits.org/core/waterfall

Demonstrates practical examples of how to use the Waterfall contract, likely including deployment and interaction scenarios.

```link
https://github.com/splits/splits-monorepo/tree/main/apps/web/src/components/Waterfall
```

--------------------------------

### Install Splits SDK with Yarn

Source: https://docs.splits.org/sdk

This snippet shows how to install the Splits SDK using the Yarn package manager. It's a common first step for developers integrating the SDK into their projects.

```bash
yarn add @0xsplits/splits-sdk
```

--------------------------------

### Install SplitsKit

Source: https://docs.splits.org/splits-kit

Install the SplitsKit package using either yarn or npm. This command adds the necessary library to your project for using SplitsKit components and hooks.

```bash
yarn add @0xsplits/splits-kit
```

```bash
npm install @0xsplits/splits-kit
```

--------------------------------

### Initialize SplitsKit with Wagmi and SplitsProvider

Source: https://docs.splits.org/splits-kit

This example demonstrates how to set up the SplitsKit environment by wrapping your application with WagmiConfig and SplitsProvider. It includes configuring chains and clients for both wagmi and Splits.

```javascript
import { WagmiConfig, createConfig, configureChains, mainnet } from'wagmi'
import { SplitsProvider } from'@0xsplits/splits-sdk-react'
import { publicProvider } from'wagmi/providers/public'
import { DisplaySplit } from'@0xsplits/splits-kit'
import'@0xsplits/splits-kit/dist/styles.css'

const SPLIT_ADDRESS='0xF8843981e7846945960f53243cA2Fd42a579f719'

const { publicClient,webSocketPublicClient } =configureChains(
  [mainnet],
  [publicProvider()],
)

constsplitsConfig= {
  chainId:1,
  publicClient,
}

constwagmiConfig=createConfig({
  publicClient,
  webSocketPublicClient,
})

exportdefaultfunctionApp() {
  return (
    <WagmiConfigconfig={wagmiConfig}>
      <SplitsProviderconfig={splitsConfig}>
        <YourComponents />
      </SplitsProvider>
    </WagmiConfig>
  )
}

functionYourComponents() {
  return (
    <div>
      <DisplaySplitchainId={1} address={SPLIT_ADDRESS} />
    </div>
  )
}
```

--------------------------------

### Use Start Vest Hook

Source: https://docs.splits.org/react

Initiates the vesting process for allocated tokens. This hook provides a function to start the vesting and includes transaction status and error handling.

```javascript
const { startVest,status,txHash,error } =useStartVest()
```

--------------------------------

### Initialize TemplatesClient with SplitsClient

Source: https://docs.splits.org/sdk/templates

Demonstrates how to import and initialize the TemplatesClient, either directly or by accessing it through an existing SplitsClient instance. This setup is necessary before calling any template functions.

```typescript
import { TemplatesClient } from'@0xsplits/splits-sdk'
consttemplatesClient=newTemplatesClient({
  chainId,
  publicClient,
  walletClient,
})
```

```typescript
import { SplitsClient } from'@0xsplits/splits-sdk'
constsplitsClient=newSplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
})
consttemplatesClient=splitsClient.templates
```

--------------------------------

### Create Swapper Contract (JavaScript/TypeScript)

Source: https://docs.splits.org/sdk/swapper

Provides an example of how to use the `createSwapper` function to deploy a new Swapper contract. It details the required arguments, including beneficiary, tokenToBeneficiary, scaling factors, owner, and optional oracle parameters.

```javascript
const args = {
  beneficiary: '0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f',
  tokenToBeneficiary: '0x0000000000000000000000000000000000000000',
  defaultScaledOfferFactorPercent: 1,
  scaledOfferFactorOverrides: [
    {
      baseToken: '0x0000000000000000000000000000000000000000',
      quoteToken: '0x0000000000000000000000000000000000000000',
      scaledOfferFactorPercent: 0.1,
    },
  ],
  owner: '0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f',
  oracleParams: {
    address: '0x8E0E20Ea43A88214A0908F32Cd14395022e823A6',
  },
}
const response = await swapperClient.createSwapper(args)
```

--------------------------------

### Get Swapper Metadata

Source: https://docs.splits.org/sdk/data

Fetches all metadata for a swapper contract address on a given chain. Requires chainId and swapperAddress as input.

```javascript
constargs= {
  chainId:1,
  swapperAddress:'0x693C49a6296d90e8A8936Ad4836a680F551bb97d',
}
constresponse=awaitdataClient.getSwapperMetadata(args)
```

--------------------------------

### Start Vesting Streams

Source: https://docs.splits.org/sdk/vesting

Initiates vesting streams for specified tokens associated with a vesting module. It takes the vesting module address and an array of token addresses as arguments. The response contains events emitted for each token stream created.

```javascript
constargs= {
  vestingModuleAddress:'0x0aab2E1E7D7bb0CAb1c0A49A59DCEfe241aA2ba1',
  tokens: [
'0x0000000000000000000000000000000000000000',
'0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
  ],
}
constresponse=awaitvestingClient.startVest(args)
```

--------------------------------

### Estimate Gas for Create Vesting Module

Source: https://docs.splits.org/sdk/vesting

Demonstrates how to estimate the gas required for the `createVestingModule` function. By accessing the `estimateGas` property of the vesting client, you can get the gas cost without executing the transaction.

```javascript
constargs= {
  beneficiary:'0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC',
  vestingPeriodSeconds:31536000,
}
constgasEstimate=awaitvestingClient.estimateGas.createVestingModule(args)
```

--------------------------------

### Distribute Token, Withdraw Funds, and Distribute Liquid Split via Multicall

Source: https://docs.splits.org/sdk/multicall

This example demonstrates how to batch three distinct operations: distributing a token via a split, withdrawing funds, and distributing a token via a liquid split. It first generates the call data for each individual operation using the respective SDK clients and then combines these call data objects into a single multicall transaction.

```javascript
const splitDistributionArgs = {
  splitAddress: "0xd9137B84f56D61Bb961082DD9Eb21bE3D7B14cB9",
  token: "0x64d91f12ece7362f91a6f8e7940cd55f05060b92",
  distributorAddress: "0x2fa128274cfcf47afd4dc03cd3f2a59af09b6a72",
}
const splitDistributionCallData = await splitsClient.callData.distributeToken(splitDistributionArgs)
const withdrawArgs = {
  address: "0xb5Ce41320F3d486671918733BB3226E3981Db62b",
  tokens: ["0x64d91f12ece7362f91a6f8e7940cd55f05060b92"],
}
const withdrawCallData = await splitsClient.callData.withdrawFunds(withdrawArgs)
const liquidSplitDistributionArgs = {
  liquidSplitAddress: "0xb5Ce41320F3d486671918733BB3226E3981Db62b",
  token: "0x64d91f12ece7362f91a6f8e7940cd55f05060b92",
  distributorAddress: "0x2fa128274cfcf47afd4dc03cd3f2a59af09b6a72",
}
const liquidSplitDistributionCallData = await splitsClient.liquidSplits.callData.distributeToken(liquidSplitDistributionArgs)
const response = await splitsClient.multicall({
  calls: [splitDistributionCallData, withdrawCallData, liquidSplitDistributionCallData],
})
```

--------------------------------

### Create Recoup Waterfall Split

Source: https://docs.splits.org/sdk/templates

Provides an example of using the `createRecoup` function to create a new Waterfall contract with multiple tranches, including a tranche with percentage-based allocations. This function simplifies the process of setting up complex distribution waterfalls.

```typescript
constargs= {
  token:"0x0000000000000000000000000000000000000000"
  tranches: [
    {
      recipient:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
      size:5.2
    },
    {
      recipient:"0xc3313847E2c4A506893999f9d53d07cDa961a675",
      size:3
    },
    {
      recipient: {
        recipients: [
            {
                address:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
                percentAllocation:50
            },
            {
                address:"0xc3313847E2c4A506893999f9d53d07cDa961a675",
                percentAllocation:30
            },
            {
                address:"0xEc8Bfc8637247cEe680444BA1E25fA5e151Ba342",
                percentAllocation:20
            }
        ],
        distributorFeePercent:1
      }
    }
  ]
}
constresponse=awaittemplatesClient.createRecoup(args)
```

--------------------------------

### Create Waterfall Module

Source: https://docs.splits.org/sdk/waterfall

Provides an example of how to create a new Waterfall contract using the `createWaterfallModule` function. It details the required arguments, including the token address and a list of tranches with recipient addresses and sizes, as well as optional non-waterfall recipient.

```javascript
const args = {
  token: "0x0000000000000000000000000000000000000000"
  tranches: [
    {
      recipient: "0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
      size: 5.2 // Receives the first 5.2 eth
    },
    {
      recipient: "0xc3313847E2c4A506893999f9d53d07cDa961a675",
      size: 3 // Receives the next 3 eth
    },
    {
      recipient: "0xEc8Bfc8637247cEe680444BA1E25fA5e151Ba342",
    }
  ]
}
const response = await waterfallClient.createWaterfallModule(args)
```

--------------------------------

### Initialize SwapperClient (JavaScript/TypeScript)

Source: https://docs.splits.org/sdk/swapper

Demonstrates how to import and initialize the SwapperClient from the Splits SDK. It shows the necessary parameters such as chainId, publicClient, walletClient, and API key configuration for interacting with the Splits GraphQL API.

```javascript
import { SwapperClient } from'@0xsplits/splits-sdk'
const swapperClient = new SwapperClient({
  chainId,
  publicClient, // viem public client (optional, required if using any of the contract functions)
  walletClient, // viem wallet client (optional, required if using any contract write functions. must have an account already attached)
  includeEnsNames, // boolean, defaults to false. If true, will return ens names for any swapper owner or beneficiary (only for mainnet)
  // If you want to return ens names on chains other than mainnet, you can pass in a mainnet public client
  // here. Be aware though that the ens name may not necessarily resolve to the proper address on the
  // other chain for non EOAs (e.g. Gnosis Safe's)
  ensPublicClient, // viem public client (optional)
  apiConfig: {
    apiKey: string // You can create an API key by signing up on our app, and accessing your account settings at app.splits.org/settings.
  }, // Splits GraphQL API key config, this is required for the data client to access the splits graphQL API.
})
```

--------------------------------

### Initialize Splits V2 Client

Source: https://docs.splits.org/sdk/splits-v2

Demonstrates how to import and initialize the SplitV2Client from the @0xsplits/splits-sdk. It outlines the necessary parameters such as chainId, publicClient, walletClient, includeEnsNames, ensPublicClient, and apiConfig with an API key.

```javascript
import { SplitV2Client } from'@0xsplits/splits-sdk'
constsplitsClient=newSplitV2Client({
  chainId,
  publicClient,// viem public client (optional, required if using any of the contract functions)
  walletClient,// viem wallet client (optional, required if using any contract write functions. must have an account already attached)
  includeEnsNames,// boolean, defaults to false. If true, will return ens names for any split recipient or controller (only for mainnet)
// If you want to return ens names on chains other than mainnet, you can pass in a mainnet public client
// here. Be aware though that the ens name may not necessarily resolve to the proper address on the
// other chain for non EOAs (e.g. Gnosis Safe's)
  ensPublicClient,// viem public client (optional)
  apiConfig: {
    apiKey: string // You can create an API key by signing up on our app, and accessing your account settings at app.splits.org/settings.
  },// Splits GraphQL API key config, this is required for the data client to access the splits graphQL API.
})
```

--------------------------------

### Initialize SplitsClient V1

Source: https://docs.splits.org/sdk/splits-v1

Initializes the Splits V1 client with necessary configurations like chain ID, public/wallet clients, ENS name inclusion, and API key for GraphQL access.

```javascript
import { SplitsClient } from'@0xsplits/splits-sdk'
constsplitsClient=newSplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
  apiConfig: {
    apiKey: string
  },
}).splitV1
```

--------------------------------

### UniV3Oracle: Get Quote Amounts

Source: https://docs.splits.org/core/oracle

This snippet demonstrates how to retrieve quote amounts using the UniV3Oracle implementation, which leverages Uniswap v3 TWAP for asset pricing. It outlines the process of consulting the oracle with specific parameters to get price information.

```Solidity
function getQuoteAmounts(address pool, uint256 amountIn, uint256 amountOut) external view returns (uint256 quoteAmountOut, uint256 quoteAmountIn) {
    // Implementation details for consulting UniV3Pools
    // ...
    return (quoteAmountOut, quoteAmountIn);
}
```

--------------------------------

### Initialize VestingClient Directly

Source: https://docs.splits.org/sdk/vesting

Shows how to initialize the VestingClient directly, providing necessary configuration options such as chainId, publicClient, walletClient, and API key for GraphQL access. This method is useful if you only need to interact with vesting features.

```javascript
import { VestingClient } from'@0xsplits/splits-sdk'
constvestingClient=newVestingClient({
  chainId,
  publicClient,// viem public client (optional, required if using any of the contract functions)
  walletClient,// viem wallet client (optional, required if using any contract write functions. must have an account already attached)
  includeEnsNames,// boolean, defaults to false. If true, will return ens names for any vesting beneficiary (only for mainnet)
// If you want to return ens names on chains other than mainnet, you can pass in a mainnet public client
// here. Be aware though that the ens name may not necessarily resolve to the proper address on the
// other chain for non EOAs (e.g. Gnosis Safe's)
  ensPublicClient,// viem public client (optional)
  apiConfig: {
    apiKey: string // You can create an API key by signing up on our app, and accessing your account settings at app.splits.org/settings.
  },// Splits GraphQL API key config, this is required for the data client to access the splits graphQL API.
})
```

--------------------------------

### Get Hash

Source: https://docs.splits.org/sdk/splits-v1

Retrieves the current hash for a given `splitAddress`.

```javascript
constargs= {
  splitAddress:'0xd9137B84f56D61Bb961082DD9Eb21bE3D7B14cB9',
}
constresponse=awaitsplitsClient.getHash(args)
```

--------------------------------

### Get Controller

Source: https://docs.splits.org/sdk/splits-v1

Retrieves the controller address for a given `splitAddress`.

```javascript
constargs= {
  splitAddress:'0xd9137B84f56D61Bb961082DD9Eb21bE3D7B14cB9',
}
constresponse=awaitsplitsClient.getController(args)
```

--------------------------------

### Initialize SplitsProvider and Fetch Split Metadata

Source: https://docs.splits.org/react

Set up the SplitsProvider with a viem public client and chain configuration. Then, use the useSplitMetadata hook to fetch and display a Split's basic metadata, including its address, controller, fee, and recipients.

```javascript
import { createPublicClient, http } from'viem'
import { mainnet } from'viem/chains'
import { SplitsProvider, useSplitMetadata } from'@0xsplits/splits-sdk-react'

const SPLIT_ADDRESS='0xF8843981e7846945960f53243cA2Fd42a579f719'

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})

const splitsConfig = {
  chainId: 1,
  publicClient,
}

function App() {
  return (
    <SplitsProvider config={splitsConfig}>
      <YourComponents />
    </SplitsProvider>
  )
}

function YourComponents() {
  const { splitMetadata, isLoading } = useSplitMetadata(1, SPLIT_ADDRESS)

  if (isLoading) return <div>Loading Split...</div>
  if (!splitMetadata) return <div>No Split found at address {SPLIT_ADDRESS}</div>

  return (
    <div>
      <div>Split: {splitMetadata.address}</div>
      {splitMetadata.controller ? (
        <div>Controlled by: {splitMetadata.controller.address}</div>
      ) : (
        <div>No controller, Split is immutable</div>
      )}
      <div>Distribution incentive: {splitMetadata.distributorFeePercent}%</div>
      <div>
        <div>Recipients</div>
        {splitMetadata.recipients.map((recipient) => (
          <div key={recipient.recipient.address}>{recipient.recipient.address}: {recipient.percentAllocation}%</div>
        ))}
      </div>
    </div>
  )
}
```

--------------------------------

### Get Split Balance

Source: https://docs.splits.org/sdk/splits-v1

Retrieves the balance for a specified `splitAddress` and an optional `token`. If no token is provided, it returns the ETH balance.

```javascript
constargs= {
  splitAddress:'0x2ed6c4B5dA6378c7897AC67Ba9e43102Feb694EE',
  token:'0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
}
constresponse=awaitsplitsClient.getSplitBalance(args)
```

--------------------------------

### Get Beneficiary

Source: https://docs.splits.org/sdk/vesting

Retrieves the beneficiary address associated with a specific vesting module address. Requires the vesting module address as input.

```javascript
const args = {
  vestingModuleAddress: '0x0aab2E1E7D7bb0CAb1c0A49A59DCEfe241aA2ba1',
};
const response = await vestingClient.getBeneficiary(args);
```

--------------------------------

### Get Token

Source: https://docs.splits.org/sdk/waterfall

Returns the token address associated with a given waterfall module address. This helps identify the asset being managed by the waterfall.

```javascript
const args = {
  waterfallModuleAddress: '0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC'
};
const response = await waterfallClient.getToken(args);
```

--------------------------------

### Get New Potential Controller

Source: https://docs.splits.org/sdk/splits-v1

Retrieves the new potential controller address for a given `splitAddress`, which is the address that needs to accept control.

```javascript
constargs= {
  splitAddress:'0xd9137B84f56D61Bb961082DD9Eb21bE3D7B14cB9',
}
constresponse=awaitsplitsClient.getNewPotentialController(args)
```

--------------------------------

### Initialize SplitsProvider

Source: https://docs.splits.org/react

Wrap your application with the SplitsProvider component to manage context for all splits hooks. Optionally, provide a splitsConfig object to initialize the SplitsClient.

```javascript
import { SplitsProvider } from'@0xsplits/splits-sdk-react'

const splitsConfig = {
  chainId: 1,
}

function App() {
  return (
    <SplitsProvider config={splitsConfig}>
      <YourComponents />
    </SplitsProvider>
  )
}

function YourComponents() {
  return <div>Hello World</div>
}
```

--------------------------------

### Get Vesting Period

Source: https://docs.splits.org/sdk/vesting

Fetches the vesting period in seconds for a given vesting module address. The input required is the vesting module address.

```javascript
const args = {
  vestingModuleAddress: '0x0aab2E1E7D7bb0CAb1c0A49A59DCEfe241aA2ba1',
};
const response = await vestingClient.getVestingPeriod(args);
```

--------------------------------

### Initialize SplitsClient Data Client

Source: https://docs.splits.org/sdk/data

Initializes the SplitsClient data client with configuration options including chainId, Viem clients, ENS name resolution, and API key for GraphQL access.

```javascript
import { SplitsClient } from'@0xsplits/splits-sdk'
constdataClient=newSplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
  apiConfig: {
    apiKey: string
  },
}).dataClient
```

```javascript
constdataClient=newDataClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
  apiConfig,
})
```

--------------------------------

### Get Vesting Metadata

Source: https://docs.splits.org/sdk/data

Fetches all metadata for a vesting module contract address on a given chain. Requires chainId and the vestingModuleAddress.

```javascript
constargs= {
  chainId:1,
  vestingModuleAddress:'0x0aab2E1E7D7bb0CAb1c0A49A59DCEfe241aA2ba1',
}
constresponse=awaitdataClient.getVestingMetadata(args)
```

--------------------------------

### Initialize WaterfallClient with Splits SDK

Source: https://docs.splits.org/sdk/waterfall

Demonstrates how to initialize the WaterfallClient directly or by accessing it through an existing SplitsClient instance. It outlines the necessary parameters like chainId, publicClient, walletClient, and API configuration.

```javascript
import { WaterfallClient } from'@0xsplits/splits-sdk'
const waterfallClient = new WaterfallClient({
  chainId,
  publicClient, // viem public client (optional, required if using any of the contract functions)
  walletClient, // viem wallet client (optional, required if using any contract write functions. must have an account already attached)
  includeEnsNames, // boolean, defaults to false. If true, will return ens names for any waterfall recipient (only for mainnet)
  // If you want to return ens names on chains other than mainnet, you can pass in a mainnet public client
  // here. Be aware though that the ens name may not necessarily resolve to the proper address on the
  // other chain for non EOAs (e.g. Gnosis Safe's)
  ensPublicClient, // viem public client (optional)
  apiConfig: {
    apiKey: string // You can create an API key by signing up on our app, and accessing your account settings at app.splits.org/settings.
  }, // Splits GraphQL API key config, this is required for the data client to access the splits graphQL API.
})
```

```javascript
import { SplitsClient } from'@0xsplits/splits-sdk'
const splitsClient = new SplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
})
const waterfallClient = splitsClient.waterfall
```

--------------------------------

### Get Account Metadata

Source: https://docs.splits.org/sdk/data

Retrieves all metadata for a specified account address on a given chain. Requires chainId and accountAddress as arguments.

```javascript
constargs= {
  chainId:1,
  accountAddress:'0xF8843981e7846945960f53243cA2Fd42a579f719',
}
constresponse=awaitdataClient.getAccountMetadata(args)
```

--------------------------------

### Initialize VestingClient with SplitsClient

Source: https://docs.splits.org/sdk/vesting

Demonstrates how to access the VestingClient through an existing SplitsClient instance. This is a convenient way to manage vesting functionalities if you are already using the SplitsClient for other operations.

```javascript
import { SplitsClient } from'@0xsplits/splits-sdk'
constsplitsClient=newSplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
})
constvestingClient=splitsClient.vesting
```

--------------------------------

### Initialize SwapperClient via SplitsClient (JavaScript/TypeScript)

Source: https://docs.splits.org/sdk/swapper

Shows an alternative method to access the SwapperClient by initializing the SplitsClient first and then accessing the swapper property. This is useful if you are already using the SplitsClient in your application.

```javascript
import { SplitsClient } from'@0xsplits/splits-sdk'
const splitsClient = new SplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
})
const swapperClient = splitsClient.swapper
```

--------------------------------

### Get Owner

Source: https://docs.splits.org/sdk/liquid

Retrieves the owner's address for a given Liquid Split contract. This is essential for contract management and ownership verification.

```javascript
const args = {
  liquidSplitAddress: '0xb5Ce41320F3d486671918733BB3226E3981Db62b',
};
const response = await liquidSplitClient.getOwner(args);
```

--------------------------------

### Get Non-Waterfall Recipient

Source: https://docs.splits.org/sdk/waterfall

Retrieves the address designated as the non-waterfall recipient for a specific waterfall module. If no such recipient was set, it returns the zero address.

```javascript
const args = {
  waterfallModuleAddress: '0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC'
};
const response = await waterfallClient.getNonWaterfallRecipient(args);
```

--------------------------------

### UniV3 Flash Swap Execution (JavaScript/TypeScript)

Source: https://docs.splits.org/sdk/swapper

Demonstrates how to perform a flash swap using the `uniV3FlashSwap` function, which leverages UniswapV3 integration. It includes parameters for the swapper address, input assets with encoded paths and amounts, and optional excess recipient and time limit.

```javascript
const args = {
  swapperAddress: '0x693C49a6296d90e8A8936Ad4836a680F551bb97d',
  inputAssets: [
    {
      encodedPath:
        '0xb4fbf271143f4fbf7b91a5ded31805e42b2208d60001f41f9840a85d5af5bf1d1762f925bdaddc4201f984',
      token: 0x0000000000000000000000000000000000000000,
      amountIn: BigInt('100000000000000000'),
      amountOutMin: BigInt('1000000000'),
    },
  ],
}
const response = await swapperClient.uniV3FlashSwap(args)
```

--------------------------------

### Get Tranches

Source: https://docs.splits.org/sdk/waterfall

Fetches the list of recipients and their corresponding tranche thresholds for a given waterfall module address. This provides insight into the distribution structure.

```javascript
const args = {
  waterfallModuleAddress: '0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC'
};
const response = await waterfallClient.getTranches(args);
```

--------------------------------

### Create Diversifier with Arguments

Source: https://docs.splits.org/sdk/templates

Demonstrates how to call the createDiversifier function with specific arguments, including owner, oracle parameters, and recipient details with optional swapper configurations. The response includes the passThroughWalletAddress and the emitted event.

```javascript
constargs= {
  owner:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
  oracleParams: {
    address:"0x8E0E20Ea43A88214A0908F32Cd14395022e823A6",
  },
  recipients: [
    {
      address:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
      percentAllocation:60
    },
    {
      swapperParams: {
        beneficiary:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
        tokenToBeneficiary:"0x0000000000000000000000000000000000000000",
        defaultScaledOfferFactorPercent:1,
        scaledOfferFactorOverrides: [
          {
            baseToken:"0x0000000000000000000000000000000000000000",
            quoteToken:"0x0000000000000000000000000000000000000000",
            scaledOfferFactorPercent:0.1,
          }
        ],
      },
      percentAllocation:40
    }
  ]
};
constresponse=awaittemplatesClient.createDiversifier(args);
```

--------------------------------

### Get TokenToBeneficiary from Swapper Contract

Source: https://docs.splits.org/sdk/swapper

Retrieves the token to beneficiary mapping for a specified swapper contract address. This is a read operation for Swapper contracts.

```javascript
const args = {
  swapperAddress: '0x693C49a6296d90e8A8936Ad4836a680F551bb97d',
};
const response = await swapperClient.getTokenToBeneficiary(args);
```

--------------------------------

### Get Split Metadata

Source: https://docs.splits.org/sdk/data

Fetches all metadata for a given split contract address on a specific chain. The function requires the chainId and the splitAddress.

```javascript
constargs= {
  chainId:1,
  splitAddress:'0xF8843981e7846945960f53243cA2Fd42a579f719',
}
constresponse=awaitdataClient.getSplitMetadata(args)
```

--------------------------------

### Swapper Contract Functions (Solidity)

Source: https://docs.splits.org/core/swapper

This snippet outlines the core functions of the Swapper smart contract, including initialization, flash swaps, and retrieving quote amounts. It details the interactions between the Swapper, Beneficiary, Oracle, and Trader during a flash swap.

```Solidity
contract Swapper {
    // ... other state variables and functions

    constructor(address _beneficiary, address _outputToken, address _oracle, uint256 _discount) payable {}

    function flash(address _token, uint256 _amount, address _integrator, bytes calldata _data) external payable returns (bool)

    function flashCallback(address _token, uint256 _amount, uint256 _fee) external

    function getQuoteAmounts(address _token, uint256 _amount) external view returns (uint256 amountOut, uint256 fee)
}
```

--------------------------------

### Generate Call Data for Create Swapper

Source: https://docs.splits.org/sdk/swapper

Generates call data for the create swapper function. This involves defining arguments such as beneficiary, tokenToBeneficiary, offer factors, owner, and oracle parameters.

```javascript
const args = {
  beneficiary: '0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f',
  tokenToBeneficiary: '0x0000000000000000000000000000000000000000',
  defaultScaledOfferFactorPercent: 1,
  scaledOfferFactorOverrides: [
    {
      baseToken: '0x0000000000000000000000000000000000000000',
      quoteToken: '0x0000000000000000000000000000000000000000',
      scaledOfferFactorPercent: 0.1,
    },
  ],
  owner: '0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f',
  oracleParams: {
    address: '0x8E0E20Ea43A88214A0908F32Cd14395022e823A6',
  },
};
const callData = await swapperClient.callData.createSwapper(args);
```

--------------------------------

### Initialize LiquidSplitClient (JavaScript/TypeScript)

Source: https://docs.splits.org/sdk/liquid

Demonstrates how to initialize the LiquidSplitClient, which is used for interacting with Liquid Splits. It can be initialized directly or accessed via an existing SplitsClient instance. Configuration options include chain ID, Viem clients, ENS name inclusion, and API key for the GraphQL API.

```typescript
import { LiquidSplitClient } from'@0xsplits/splits-sdk'

const liquidSplitClient = new LiquidSplitClient({
  chainId,
  publicClient, // viem public client (optional, required if using any of the contract functions)
  walletClient, // viem wallet client (optional, required if using any contract write functions. must have an account already attached)
  includeEnsNames, // boolean, defaults to false. If true, will return ens names for any liquid split holder (only for mainnet)
  // If you want to return ens names on chains other than mainnet, you can pass in a mainnet public client
  // here. Be aware though that the ens name may not necessarily resolve to the proper address on the
  // other chain for non EOAs (e.g. Gnosis Safe's)
  ensPublicClient, // viem public client (optional)
  apiConfig: {
    apiKey: string // You can create an API key by signing up on our app, and accessing your account settings at app.splits.org/settings.
  }, // Splits GraphQL API key config, this is required for the data client to access the splits graphQL API.
});
```

```typescript
import { SplitsClient } from'@0xsplits/splits-sdk'

const splitsClient = new SplitsClient({
  chainId,
  publicClient,
  walletClient,
  includeEnsNames,
  ensPublicClient,
});

const liquidSplitClient = splitsClient.liquidSplits;
```

--------------------------------

### Get Funds Pending Withdrawal

Source: https://docs.splits.org/sdk/waterfall

Returns the amount of funds that are pending withdrawal for a given waterfall module address. This is relevant for pull payment mechanisms.

```javascript
const args = {
  waterfallModuleAddress: '0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC'
};
const response = await waterfallClient.getFundsPendingWithdrawal(args);
```

--------------------------------

### Get Beneficiary from Swapper Contract

Source: https://docs.splits.org/sdk/swapper

Retrieves the beneficiary address associated with a given swapper contract address. This function is part of the Swapper Reads utility.

```javascript
const args = {
  swapperAddress: '0x693C49a6296d90e8A8936Ad4836a680F551bb97d',
};
const response = await swapperClient.getBeneficiary(args);
```

--------------------------------

### Create Split Contract

Source: https://docs.splits.org/sdk/splits-v2

Shows how to create a new Split contract using the `createSplit` method. It details the required arguments like recipients, distributorFeePercent, and ownerAddress, and explains the optional parameters such as salt and chainId. The response includes the splitAddress and the emitted event.

```javascript
constargs= {
  recipients: [
    {
      address:"0x442C01498ED8205bFD9aaB6B8cc5C810Ed070C8f",
      percentAllocation:50.0000
    },
    {
      address:"0xc3313847E2c4A506893999f9d53d07cDa961a675",
      percentAllocation:50.0000
    }
  ],
  distributorFeePercent:1.0000,
  totalAllocationPercent:100.0000,
  splitType:SplitV2Type.Push,
  ownerAddress:"0xEc8Bfc8637247cEe680444BA1E25fA5e151Ba342",
  creatorAddress:"0xEc8Bfc8637247cEe680444BA1E25fA5e151Ba342",
  salt:"0x0000000000000000000000000000000000000000000000000000000000000000",
  chainId:1
}
constresponse=awaitsplitsClient.createSplit(args)
```

--------------------------------

### Use Create Swapper Hook

Source: https://docs.splits.org/react

Provides functionality to create a swapper, likely for facilitating token exchanges. The hook returns a function to initiate the creation and tracks the transaction status.

```javascript
const { createSwapper,status,txHash,error } =useCreateSwapper()
```

--------------------------------

### Get Related Splits by Address

Source: https://docs.splits.org/sdk/data

Retrieves all Splits associated with a specific blockchain address. This function requires the chain ID and the address to query.

```javascript
const args = {
  chainId: 1,
  address: '0xEc8Bfc8637247cEe680444BA1E25fA5e151Ba342'
};
const response = await dataClient.getRelatedSplits(args);
```

--------------------------------

### Get Waterfall Metadata

Source: https://docs.splits.org/sdk/data

Retrieves all metadata for a waterfall module contract address on a specified chain. The function takes chainId and waterfallModuleAddress as arguments.

```javascript
constargs= {
  chainId:1,
  waterfallModuleAddress:'0x8904D1fBfc9c88792aaaE8f452ac57E1Ba2130fC',
}
constresponse=awaitdataClient.getWaterfallMetadata(args)
```

--------------------------------

### Get Uri

Source: https://docs.splits.org/sdk/liquid

Fetches the Uniform Resource Identifier (URI) for a specified Liquid Split contract address. This can be used to retrieve metadata or related resources.

```javascript
const args = {
  liquidSplitAddress: '0xb5Ce41320F3d486671918733BB3226E3981Db62b',
};
const response = await liquidSplitClient.getUri(args);
```
Tokens:
Raw