Honeycomb Protocol

https://docs.honeycombprotocol.com
Admin
Honeycomb Protocol is a comprehensive suite of tools built on the Solana blockchain, designed to...
Tokens:243,177
Snippets:946
Trust Score:5.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install Unity SDK via Git URL

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

This snippet provides the Git URL for installing the main Honeycomb Unity SDK into your project.

```git-url
https://github.com/Honeycomb-Protocol/Unity-SDK.git
```

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

### Install Dependencies with NPM

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Installs all required dependencies for the Honeycomb Protocol and Solana wallet adapters using npm. This is the first step in setting up your JavaScript application.

```bash
npm install @solana/wallet-adapter-react @solana/wallet-adapter-base @solana/wallet-adapter-wallets @solana/wallet-adapter-react-ui @solana/web3.js @honeycomb-protocol/edge-client bs58  
```

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

### Install Dependencies with Yarn

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Installs all required dependencies for the Honeycomb Protocol and Solana wallet adapters using yarn. This is an alternative to npm for dependency management.

```bash
yarn add @solana/wallet-adapter-react @solana/wallet-adapter-base @solana/wallet-adapter-wallets @solana/wallet-adapter-react-ui @solana/web3.js @honeycomb-protocol/edge-client bs58  
```

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

### Install Solana Unity SDK via Git URL

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

This snippet shows the Git URL to add the Honeycomb Solana SDK to your Unity project using the Package Manager.

```git-url
https://github.com/Honeycomb-Protocol/Solana.Unity-SDK.git
```

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

### Create, Sign, and Send Project Transaction

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

C# example of creating a project transaction using the HplClient, signing it with TransactionHelper, and sending it to the blockchain.

```csharp
var tx = await Client.CreateCreateProjectTransaction(  
    new CreateCreateProjectTransactionParams  
    {  
        Name = "My Project", // Set the name of the project  
        Authority = "My Authority" // Set the authority for the project  
    }  
);

// Initialize a TransactionHelper with the created transaction  
var txHelper = new TransactionHelper(  
    tx.CreateCreateProjectTransaction.Tx // Extract the transaction object  
);

// Sign the transaction  
await txHelper.Sign();

// Send the signed transaction  
var res = await Client.SendBulkTransactions(  
    txHelper.ToSendParams() // Populates the transaction parameters for sending  
);

```

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

### Create Web3 User Profiles with Honeycomb Protocol

Source: https://docs.honeycombprotocol.com/usage-guides/start-using-profiles

This code snippet demonstrates how to create a new Web3 profile for a user upon their first interaction with your application. It utilizes the Honeycomb Protocol client to generate and send the necessary transaction. Ensure the '@solana/wallet-adapter-react' and '@honeycomb-protocol/edge-client' libraries are installed and the client utility is properly configured.

```javascript
import { useWallet } from "@solana/wallet-adapter-react";  
import { sendClientTransactions } from "@honeycomb-protocol/edge-client/client/walletHelpers";  
import { client } from "@/utils"; // Import the client (covered in the dev environment setup)  
  
const wallet = useWallet();  
  
const {   
  createNewUserWithProfileTransaction: txResponse // This is the transaction response, you'll need to sign and send this transaction  
} = await client.createNewUserWithProfileTransaction({  
    project: projectAddress.toString(),  
    wallet: userPublicKey.toString(),  
    payer: adminPublicKey.toString(),  
    profileIdentity: "main",  
    userInfo: {  
        name: "John Doe",  
        bio: "This user is created for testing purposes",  
        pfp: "https://lh3.googleusercontent.com/-Jsm7S8BHy4nOzrw2f5AryUgp9Fym2buUOkkxgNplGCddTkiKBXPLRytTMXBXwGcHuRr06EvJStmkHj-9JeTfmHsnT0prHg5Mhg",  
    }  
});  
  
await sendClientTransactions(client, wallet, txResponse); // Get the transaction signed by the user and send it to the blockchain  

```

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

### Full Application Setup with Tiplink Wallet Adapter

Source: https://docs.honeycombprotocol.com/usage-guides/tiplink-adapter

A complete example of a React application setup that integrates the Tiplink Wallet Adapter alongside other popular Solana wallets like Phantom and Solflare. It includes necessary imports, network configuration, and wallet provider setup.

```javascript
import { useMemo } from "react";  
import { useSearchParams } from "react-router-dom";  
import {  
  ConnectionProvider,  
  WalletProvider,  
} from "@solana/wallet-adapter-react";  
import {  
  PhantomWalletAdapter,  
  SolflareWalletAdapter,  
} from "@solana/wallet-adapter-wallets";  
import {  
  WalletModalProvider,  
  WalletMultiButton,  
} from "@solana/wallet-adapter-react-ui";  
import { TipLinkWalletAdapter } from "@tiplink/wallet-adapter";  
import { TipLinkWalletAutoConnectV2 } from "@tiplink/wallet-adapter-react-ui";  
import "./App.css";  
  
// Default styles that can be overridden by your app  
import "@solana/wallet-adapter-react-ui/styles.css";  
  
function App() {  
  // The network can be set to 'devnet', 'testnet', or 'mainnet-beta'.  
  const network = "https://rpc.test.honeycombprotocol.com";  
  // You can also provide a custom RPC endpoint.  
  const endpoint = useMemo(() => network, [network]);  
  
  const wallets = useMemo(  
    () => [  
      // Manually define specific/custom wallets here  
      new PhantomWalletAdapter(),  
      new SolflareWalletAdapter(),  
      // Add the TipLink Wallet Adapter  
      new TipLinkWalletAdapter({  
        title: "Name of Dapp",  
        clientId: "694bf97c-d2ac-4dfc-a786-a001812658df", // This is the client ID you get from TipLink  
        theme: "dark", // pick between "dark"/"light"/"system"  
      }),  
    ],  
    [network]  
  );  
  
const [searchParams, setSearchParams] = useSearchParams();  
  
  return (  
    <ConnectionProvider endpoint={endpoint}>  
      <WalletProvider wallets={wallets} autoConnect>  
       <TipLinkWalletAutoConnectV2 isReady={true} query={searchParams}>  
            <WalletModalProvider>  
                <WalletMultiButton />  
                <h1>Hello Solana</h1>  
            </WalletModalProvider>  
        </TipLinkWalletAutoConnectV2>  
      </WalletProvider>  
    </ConnectionProvider>  
  );  
}  
  
export default App;  
```

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

### Add Ingredients to Recipe (Unity/C#)

Source: https://docs.honeycombprotocol.com/resources

This section provides instructions for adding ingredients to a recipe using the Honeycomb Protocol SDK for Unity/C#. It includes C# code examples for parameter setup and transaction creation.

```APIDOC
## POST /websites/honeycombprotocol/recipes/ingredients (Unity/C# SDK)

### Description
Use the Unity/C# SDK to add ingredients to a recipe. This involves creating a transaction using the client library.

### Method
POST

### Endpoint
(This is an SDK method, not a direct HTTP endpoint. The SDK handles the communication.)

### Parameters
(These are parameters for the SDK method `Client.CreateAddIngredientsTransaction`)
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
(Represented by the `CreateAddIngredientsTransactionParams` object)
- **Recipe** (PublicKey) - Required - The public key of the recipe.
- **Authority** (PublicKey) - Required - The public key of the authority.
- **Payer** (PublicKey) - Optional - The public key of the wallet that will pay for the transaction.
- **Ingredients** (List<IngredientsInput>) - Required - A list of ingredient inputs.
  - **ResourceAddress** (PublicKey) - Required - The public key of the ingredient resource.
  - **Amount** (string) - Required - The amount of the ingredient resource.

### Request Example
```csharp
var addIngredientsTransaction = await Client.CreateAddIngredientsTransaction(new CreateAddIngredientsTransactionParams
{
    Recipe = recipeAddress, // PublicKey
    Authority = adminPublicKey, // PublicKey
    Payer = adminPublicKey, // Optional PublicKey
    Ingredients = new List<IngredientsInput>
    {
        new IngredientsInput
        {
            ResourceAddress = ingredientAddress, // PublicKey
            Amount = "100" // string representing the amount
        }
    }
});

var txResponse = addIngredientsTransaction.CreateAddIngredientsTransaction; // Access the transaction response
```

### Response
#### Success Response (200)
(The SDK method returns a response object containing transaction details.)
- **CreateAddIngredientsTransaction** (object) - Contains the transaction details.
  - **Transactions** (string) - The transaction payload.
  - **Blockhash** (string) - The block hash.
  - **LastValidBlockHeight** (long) - The last valid block height.

#### Response Example
```csharp
// Assuming addIngredientsTransaction is the result from the SDK call
// The actual response structure might vary slightly based on the SDK version
// Example of accessing transaction data (conceptual):
var transactionPayload = addIngredientsTransaction.Transactions;
var blockHash = addIngredientsTransaction.Blockhash;
var lastValidHeight = addIngredientsTransaction.LastValidBlockHeight;
```
```

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

### Profile Setup API

Source: https://docs.honeycombprotocol.com/references

Endpoint for initiating the setup of a new profiles tree.

```APIDOC
## POST /api/profiles/tree/setup

### Description
Creates a transaction for a new profiles tree. This is the initial step for setting up a new profile structure.

### Method
POST

### Endpoint
/api/profiles/tree/setup

### Parameters
*Note: Specific arguments for this endpoint are not detailed in the provided text, but it returns a `TreeSetupResponse`.*

### Request Example
*Refer to GraphQL schema or other documentation for specific request payload.*.

### Response
#### Success Response (200)
- **treeSetupResponse** (TreeSetupResponse) - An object containing details related to the successful setup of the profiles tree.

#### Response Example
*Refer to GraphQL schema or other documentation for specific response structure.*
```

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

### InitResourceInput Example

Source: https://docs.honeycombprotocol.com/references

Example JSON for initializing a resource, specifying its name, symbol, URI, decimals, and storage type.

```json
{
  "name": "abc123",
  "symbol": "xyz789",
  "uri": "abc123",
  "decimals": 987,
  "storage": "AccountState"
}
```

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

### IngredientsInput Example

Source: https://docs.honeycombprotocol.com/references

Example JSON for inputting ingredient details, including the resource address and amount.

```json
{
  "resourceAddress": "xyz789",
  "amount": {}
}
```

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

### Setup Honeycomb Client for Mainnet-beta

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

C# code to initialize the HplClient for connecting to the Honeycomb Protocol Mainnet-beta RPC endpoint.

```csharp
using HplEdgeClient.Client;  
  
public static class Honeycomb  
{  
    private const string API_URL = "https://edge.main.honeycombprotocol.com/";  
  
    public static HplClient Client { get; } = new HplClient(API_URL);  
}  
```

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

### Project Global Configuration Example

Source: https://docs.honeycombprotocol.com/references

An example of the Global structure for project configuration, including address, bump, config, userTrees, and totalUsers.

```json
{
  "address": Bytes,
  "bump": 987,
  "config": VecMap,
  "userTrees": ControlledMerkleTrees,
  "totalUsers": 987
}
```

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

### Service Delegation Examples (JSON)

Source: https://docs.honeycombprotocol.com/references

Examples of input structures for various service delegations, such as Asset Assembler, Asset Manager, Currency Manager, Nectar Staking, Nectar Missions, and Buzz Guild. These examples demonstrate the expected JSON format for each delegation type.

```json
{
  "index": 987,
  "permission": "ManageAssembler"
}

```

```json
{
  "index": 123,
  "permission": "ManageAssets"
}

```

```json
{
  "permission": "ManageCurrencies"
}

```

```json
{
  "index": 987,
  "permission": "ManageStakingPool"
}

```

```json
{
  "index": 123,
  "permission": "ManageMissionPool"
}

```

```json
{
  "index": 987,
  "permission": "ManageGuildKit"
}

```

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

### CreateInitializeRecipeTransactionResponse Example

Source: https://docs.honeycombprotocol.com/references

Example structure for the response of creating an initialize recipe transaction, containing the transactions and serialized recipe data.

```json
{
  "transactions": Transactions,
  "recipe": Bytes
}
```

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

### Wallets Structure Example

Source: https://docs.honeycombprotocol.com/references

Example JSON for Wallets associated with a user, including a shadow wallet and a list of other wallet addresses.

```json
{
  "shadow": Pubkey,
  "wallets": [Pubkey]
}
```

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

### Import Namespaces for Transaction Handling

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

C# code demonstrating the necessary `using` statements for interacting with Honeycomb Protocol's transaction parameters and helper utilities.

```csharp
using HplEdgeClient.Params;  
using HplEdgeClient.Helpers;  
```

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

### Frontend Setup for Mainnet-beta RPC

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Configures the frontend application to connect to the Solana Mainnet-beta RPC using Honeycomb Protocol. It sets up wallet providers and modal for user interaction.

```jsx
import { useMemo } from "react";
import {
  ConnectionProvider,
  WalletProvider,
} from "@solana/wallet-adapter-react";
import {
  PhantomWalletAdapter,
  SolflareWalletAdapter,
} from "@solana/wallet-adapter-wallets";
import {
  WalletModalProvider,
  WalletMultiButton,
} from "@solana/wallet-adapter-react-ui";
import "./App.css";

// Default styles that can be overridden by your app
import "@solana/wallet-adapter-react-ui/styles.css";

function App() {
  // The network can be set to 'mainnet-beta', 'honeynet', or 'sonic'.
  const network = "https://rpc.main.honeycombprotocol.com";
  const endpoint = useMemo(() => network, [network]);

  const wallets = useMemo(
    () => [
      // Manually define specific/custom wallets here
      new PhantomWalletAdapter(),
      new SolflareWalletAdapter(),
    ],
    [network]
  );

  return (
    <ConnectionProvider endpoint={endpoint}>
      <WalletProvider wallets={wallets} autoConnect>
        <WalletModalProvider>
          <WalletMultiButton />
          <h1>Hello Solana</h1>
        </WalletModalProvider>
      </WalletProvider>
    </ConnectionProvider>
  );
}

export default App;
```

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

### Frontend Setup for Honeynet RPC

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Configures the frontend application to connect to the Solana Honeynet RPC using Honeycomb Protocol. It sets up wallet providers and modal for user interaction.

```jsx
import { useMemo } from "react";
import {
  ConnectionProvider,
  WalletProvider,
} from "@solana/wallet-adapter-react";
import {
  PhantomWalletAdapter,
  SolflareWalletAdapter,
} from "@solana/wallet-adapter-wallets";
import {
  WalletModalProvider,
  WalletMultiButton,
} from "@solana/wallet-adapter-react-ui";
import "./App.css";

// Default styles that can be overridden by your app
import "@solana/wallet-adapter-react-ui/styles.css";

function App() {
  // The network can be set to 'mainnet-beta', 'honeynet', or 'sonic'.
  const network = "https://rpc.test.honeycombprotocol.com";
  const endpoint = useMemo(() => network, [network]);

  const wallets = useMemo(
    () => [
      // Manually define specific/custom wallets here
      new PhantomWalletAdapter(),
      new SolflareWalletAdapter(),
    ],
    [network]
  );

  return (
    <ConnectionProvider endpoint={endpoint}>
      <WalletProvider wallets={wallets} autoConnect>
        <WalletModalProvider>
          <WalletMultiButton />
          <h1>Hello Solana</h1>
        </WalletModalProvider>
      </WalletProvider>
    </ConnectionProvider>
  );
}

export default App;
```

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

### Create Badge Criteria Input Data Structure

Source: https://docs.honeycombprotocol.com/references

Details the input for creating badge criteria. It requires project address, authority, and badge index. Optional parameters include payer, start time, end time, and the badge condition. The example shows a populated object.

```json
{
  "projectAddress": "Pubkey",
  "authority": "Pubkey",
  "payer": "Pubkey",
  "startTime": 987,
  "endTime": 123,
  "badgeIndex": 123,
  "condition": "Public"
}
```

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

### Add Custom Data to User Profiles with Honeycomb Protocol

Source: https://docs.honeycombprotocol.com/usage-guides/start-using-profiles

This snippet shows how to assign custom data to your users' profiles if custom data fields have been defined for your project. It generates a transaction to update the profile with new custom data. Prerequisites include having the '@solana/wallet-adapter-react' and '@honeycomb-protocol/edge-client' libraries installed and the client utility configured.

```javascript
import { useWallet } from "@solana/wallet-adapter-react";  
import { sendClientTransactions } from "@honeycomb-protocol/edge-client/client/walletHelpers";  
import { client } from "@/utils"; // Import the client (covered in the dev environment setup)  
  
const wallet = useWallet();  
  
const { createUpdateProfileTransaction: txResponse } =  
  await client.createUpdateProfileTransaction(  
    {  
      profile: profileAddress,  
      customData: {  
        add: {  
          bugsReported: ["10"],  
        },  
      },  
      payer: userPublicKey.toString(),  
    }  
  );  
  
await sendClientTransactions(client, wallet, txResponse); // Get the transaction signed by the user and send it to the blockchain  

```

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

### Airdrop SOL for Honeynet

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

Command-line instruction to airdrop SOL to a wallet address for testing on the Honeycomb Protocol's Honeynet RPC.

```bash
solana airdrop <amount> <wallet address> -u https://rpc.test.honeycombprotocol.com  
```

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

### Faucet Configuration Example

Source: https://docs.honeycombprotocol.com/references

Example structure for a Faucet, including its address, associated project, resource, dispensed amount, and timing details for claims.

```json
{
  "address": Bytes,
  "project": Pubkey,
  "resource": Pubkey,
  "amount": {},
  "repeatInterval": {},
  "lastClaimed": {}
}
```

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

### NectarMissionsPermissionInput Enum Example

Source: https://docs.honeycombprotocol.com/references

Example of the NectarMissionsPermissionInput, an enum representing permissions for managing mission pools. The example shows one permission value, 'ManageMissionPool'.

```json
"ManageMissionPool"
```

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

### BuzzGuildPermissionInput Enum Example

Source: https://docs.honeycombprotocol.com/references

Example of the BuzzGuildPermissionInput, an enum representing permissions related to guild kits. The example shows a single permission value, 'ManageGuildKit'.

```json
"ManageGuildKit"
```

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

### EarnedRewardsFilter Data Structure Example

Source: https://docs.honeycombprotocol.com/references

Example of the EarnedRewardsFilter data structure, used for filtering earned rewards. It allows filtering by delta (Int) and rewardIdx (Int). The example shows sample integer values.

```json
{"delta": 987, "rewardIdx": 987}
```

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

### GuildRole Data Structure Example

Source: https://docs.honeycombprotocol.com/references

Example of the GuildRole data structure, specifying a role within a guild. It contains a single field 'kind' of type String. The example provides a sample string value.

```json
{"kind": "xyz789"}
```

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

### ResourceKindParamsHplNonFungible Example

Source: https://docs.honeycombprotocol.com/references

Example JSON for a non-fungible resource, detailing its characteristics.

```json
{
  "characteristics": ["abc123"]
}
```

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

### EarnedRewards Data Structure Example

Source: https://docs.honeycombprotocol.com/references

Example of the EarnedRewards data structure, representing rewards obtained from a mission. It includes delta (Int), rewardIdx (Int), and collected (Boolean). The example provides sample integer values and a boolean.

```json
{"delta": 987, "rewardIdx": 987, "collected": false}
```

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

### Multiplier Structure Example

Source: https://docs.honeycombprotocol.com/references

Example structure for a Multiplier, including its value and type.

```json
{
  "value": "BigInt",
  "multiplierType": "MultiplierType"
}
```

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

### Create Honeycomb Project Transaction

Source: https://docs.honeycombprotocol.com/usage-guides/start-using-profiles

Initiates the creation of a new project within Honeycomb Protocol. Requires wallet connection and specifies project details like name, authority, payer, and profile data configuration. This transaction response needs to be signed and sent to the blockchain.

```typescript
import { useWallet } from "@solana/wallet-adapter-react";  
import { sendClientTransactions } from "@honeycomb-protocol/edge-client/client/walletHelpers";  
import { client } from "@/utils"; // Import the client (covered in the dev environment setup)  
  
const wallet = useWallet();  
  
const {  
  createCreateProjectTransaction: {  
    project: projectAddress, // Save this project address in your database, you'll need it to interact with the Web3 side of your app  
    tx: txResponse, // This is the transaction response you'll need to send to the blockchain after signing  
  },  
} = await client.createCreateProjectTransaction({  
  name: "My First Project",  
  authority: authorityPublicKey, // The wallet public key of the authority, the authority has complete control over the project  
  payer: payerPublicKey, // The wallet public key of the payer, the payer pays for the transaction fees  
  profileDataConfig: {  
    achievements: [ // Specify an array of achievements that you can give to your users  
      "Pioneer"  
    ],
    customDataFields: [ // Specify an array of custom data fields that you can set on your users' profiles  
      "bugsReported"
    ]  
  }
});

await sendClientTransactions(client, wallet, txResponse); // Get the transaction signed by the user and send it to the blockchain  

```

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

### Setup Honeycomb Edge Client for React/Node.js

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Initializes the Honeycomb Edge Client for use in a React application or Node.js backend. It requires an API URL and a boolean indicating whether to use production mode.

```javascript
import createEdgeClient from "@honeycomb-protocol/edge-client";

const API_URL = "https://edge.main.honeycombprotocol.com/";

export const client = createEdgeClient(API_URL, true);
```

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

### UsedByGuild Data Structure Example

Source: https://docs.honeycombprotocol.com/references

Example of the UsedByGuild data structure, representing a character's association with a guild. It includes guild ID (Pubkey), role (GuildRole), and order (Int). The example uses placeholders for Pubkey and GuildRole.

```json
{
  "id": Pubkey,
  "role": GuildRole,
  "order": 123
}
```

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

### Initialize Honeycomb Protocol Edge Client

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Sets up the Honeycomb Protocol edge client for use in React or Node.js applications. It requires the API endpoint URL and a boolean indicating if it's a test environment.

```javascript
import createEdgeClient from "@honeycomb-protocol/edge-client";

const API_URL = "https://edge-sonic.test.honeycombprotocol.com/";

export const client = createEdgeClient(API_URL, true);
```

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

### MultiplierTypeParamsStakeDuration Example

Source: https://docs.honeycombprotocol.com/references

Example structure for MultiplierTypeParamsStakeDuration, specifying the minimum duration for a stake-based multiplier.

```json
{
  "minDuration": "BigInt"
}
```

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

### Initiate Cooking Process Transactions (Godot)

Source: https://docs.honeycombprotocol.com/resources

A Python-like example for Godot Engine to initiate cooking transactions. It requires recipe, user, and optionally payer addresses. The response contains the necessary transaction data.

```python
client.create_init_cooking_process_transactions(
  recipe_address, 
  user_address, 
  payer_address 
)

var response = await client.query_response_received
var transactions = response.createInitCookingProcessTransactions

```

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

### BadgeCriteria Data Structure Example

Source: https://docs.honeycombprotocol.com/references

Example of the BadgeCriteria data structure used for defining conditions to earn badges. It includes startTime, endTime (BigInt), index (Int), and condition (BadgesCondition). The example shows placeholder values for time and a string for condition.

```json
{"startTime": {}, "endTime": {}, "index": 123, "condition": "Public"}
```

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

### Sign and Send Transaction (Client-Side)

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Enables signing and sending transactions from a client-side React application using the Solana wallet adapter. It involves retrieving the user's wallet and then using a helper function to sign and execute the transaction.

```javascript
import { useWallet } from "@solana/wallet-adapter-react";
import { sendClientTransactions } from "@honeycomb-protocol/edge-client/client/walletHelpers";
import { client } from "@/constants";

const wallet = useWallet();

// Create a transaction
const { createCreateProjectTransaction: { tx: txResponse } } = await client.createCreateProjectTransaction({
    name: "My Project",
    authority: wallet.publicKey.toBase58()!,
});

// Get the transaction signed by the user and send it to the blockchain
const response = await sendClientTransactions(
    client, // The client instance you created earlier in the setup
    wallet, // The wallet you got from the useWallet hook
    txResponse // You can pass the transaction response containing either a single transaction or an array of transactions
);
```

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

### MultiplierType Structure Example

Source: https://docs.honeycombprotocol.com/references

Example structure for MultiplierType, defining the kind of multiplier and its associated parameters.

```json
{
  "kind": "xyz789",
  "params": "MultiplierTypeParamsStakeDuration"
}
```

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

### Airdrop SOL for Honeynet Testing

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

A command-line utility to request SOL from the Honeynet faucet for testing purposes. This is a prerequisite for making transactions on the test network.

```bash
solana airdrop <amount> <wallet address> -u https://rpc.test.honeycombprotocol.com
```

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

### MealInput Example

Source: https://docs.honeycombprotocol.com/references

Example JSON for inputting meal details, specifying the resource address and amount.

```json
{
  "resourceAddress": "abc123",
  "amount": {}
}
```

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

### Install Tiplink Wallet Adapter Packages (NPM)

Source: https://docs.honeycombprotocol.com/usage-guides/tiplink-adapter

Installs the necessary Tiplink Wallet Adapter packages using NPM. These packages are required for integrating Tiplink's authentication with your frontend application.

```bash
npm i @tiplink/wallet-adapter @tiplink/wallet-adapter-react-ui  
```

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

### Setup Honeycomb Client for Honeynet Testnet

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/unity

C# code to initialize the HplClient for connecting to the Honeycomb Protocol Honeynet (test RPC) endpoint.

```csharp
using HplEdgeClient.Client;  
  
public static class Honeycomb  
{  
    private const string API_URL = "https://edge.test.honeycombprotocol.com/";  
  
    public static HplClient Client { get; } = new HplClient(API_URL);  
}  
```

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

### Create Project Transaction in GDScript

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/godot

This GDScript code initializes the HoneyComb client, sets the URL, creates a project, extracts the project address and transaction data from the response, and then processes the transaction. It assumes the existence of `extract_transaction` and `process_transaction` functions.

```GDScript
func _ready() -> void:
	client = HoneyComb.new()
	client.set_honeycomb_url("https://edge.test.honeycombprotocol.com")
  
    # Create a project
	client.create_create_project_transaction("Authority Publickey", "Project Name")
	var response = await client.query_response_received
      
    # Extract the project address from the response
	var project_address = response.createCreateProjectTransaction.projectAddress
  
    # Extract the transaction from the response
	var encoded_tx = extract_transaction(response.createCreateProjectTransaction)
  
    # Process and send the transaction
	if not encoded_tx.is_empty():
		await process_transaction(encoded_tx, [authority])
```

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

### Honeycomb Protocol ResourceKindParamsWrappedMplCore Example

Source: https://docs.honeycombprotocol.com/references

An example of the ResourceKindParamsWrappedMplCore structure, used for specifying characteristics associated with a resource.

```json
{
  "characteristics": ["xyz789"]
}
```

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

### Honeycomb Protocol ResourceStorage Example

Source: https://docs.honeycombprotocol.com/references

An example of the ResourceStorage structure, defining the kind and parameters for resource sourcing.

```json
{
  "kind": "AccountState",
  "params": ResourceStorageParams
}
```

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

### Sign and Send Transaction (Server-Side)

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/javascript

Facilitates signing and sending transactions from a server-side Node.js application. It requires creating a web3.js Keypair from a secret key file and using a helper function to send the transaction with the signer.

```javascript
import path from "path";
import fs from "fs";
import * as web3 from "@solana/web3.js";
import { sendTransactions } from "@honeycomb-protocol/edge-client/client/helpers";
import { client } from "@/constants";

const signer = web3.Keypair.fromSecretKey( // Create a keypair from the secret key to sign the transaction (only a keypair can sign a transaction, not just the private or public key)
    Uint8Array.from(
        JSON.parse(
            fs.readFileSync(path.resolve(__dirname, "./keys", "myKey.json"), "utf8") // Replace this with the path to your key file
        )
    )
);

// Create a transaction
const { createCreateProjectTransaction: { tx: txResponse } } = await client.createCreateProjectTransaction({
      name: "My Project",
      authority: authorityPublicKey,
      payer: payerPublicKey,
});

// Send the transaction
const response = await sendTransactions(
  client, // The client instance you created earlier in the setup
  {
    transactions: [txResponse.transaction], // If the transaction response contains only one transaction; in case of multiple transactions pass txResponse.transactions without the array brackets
    blockhash: txResponse.blockhash,
    lastValidBlockHeight: txResponse.lastValidBlockHeight,
  },
  [signer] // An array of signers
);
```

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

### MultiplierTypeParamsNFTCount Example

Source: https://docs.honeycombprotocol.com/references

Example structure for MultiplierTypeParamsNFTCount, specifying the minimum number of NFTs required for a count-based multiplier.

```json
{
  "minCount": "BigInt"
}
```

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

### LockType Structure Example

Source: https://docs.honeycombprotocol.com/references

Example structure for LockType, specifying the type of lock associated with a staking pool.

```json
{
  "kind": "abc123"
}
```

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

### Godot: Transaction Helper Functions

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/godot

Provides utility functions for handling Solana transactions within Godot. It includes methods to extract raw transaction data from responses, send partially signed transactions, and process the transaction lifecycle, awaiting its response.

```gdscript
func extract_transaction(response: Dictionary):
	if response.has("tx"):
		return response.tx.transaction
	elif response.has("transaction"):
		return response.transaction
	return ""

func send_transaction_func(encoded_transaction: String, signers: Array[Keypair], skip_preflight: bool = false):
	var decoded_tx = SolanaUtils.bs58_decode(encoded_transaction)
	var transaction: Transaction= Transaction.new_from_bytes(decoded_tx)
	add_child(transaction)

	ransaction.set_signers(signers)
	print("Signing transaction...")
	ransaction.partially_sign(signers)
	ransaction.skip_preflight = skip_preflight
	ransaction.send()
	return transaction

func process_transaction(encoded_transaction: String, signers: Array[Keypair], skip_preflight: bool = false):
	var tx = await send_transaction_func(encoded_transaction, signers, skip_preflight)
	if not tx:
		print("Failed to create transaction")
		return

	print("Transaction sent, awaiting response...")
	var response = await tx.transaction_response_received
	tx.queue_free()
	  
	return response

```

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

### Godot: Initialize Honeycomb Client for Mainnet-beta

Source: https://docs.honeycombprotocol.com/getting-started/setting-up-your-dev-environment/godot

Initializes the HoneyComb client in Godot and sets the URL for the mainnet-beta edge. This script is intended to be attached to a Godot Node and is executed when the node enters the scene tree.

```gdscript
extends Node
var client: HoneyComb

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	client = HoneyComb.new()
	client.set_honeycomb_url("https://edge.main.honeycombprotocol.com")

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

```

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

### Badges Condition Enum Example

Source: https://docs.honeycombprotocol.com/references

An example of the BadgesCondition enum value, representing a public badge condition.

```plaintext
"Public"
```
Tokens:
Raw