# Extending Chain

import { createHiveChain, TWaxApiRequest } from '@hiveio/wax';

const chain = await createHiveChain();

interface IsKnownTransactionRequest {
  id: string;
}

interface IsKnownTransactionResponse {
  is_known: boolean;
}

// Create the proper API structure
type TExtendedApi = {
  database_api: { // API
    is_known_transaction: TWaxApiRequest<
      IsKnownTransactionRequest,
      IsKnownTransactionResponse
    >; // Method
  }
};

const extended = chain.extend<TExtendedApi>();

// Call the database_api API using our extended interface
const result = await extended.api.database_api.is_known_transaction({
  id: "0000000000000000000000000000000000000000"
});

console.info(result);

import asyncio

from msgspec import Struct

from beekeepy.handle.remote import AbstractAsyncApi
from wax import create_hive_chain


class BlockHeader(Struct):
    previous: str
    timestamp: str
    witness: str
    transaction_merkle_root: str
    extensions: list


# Define a class-structure for the block header using msgspec's Struct
class BlockHeaderResponse(Struct):
    header: BlockHeader  # Define a structure for the block header using msgspec's Struct


# Define an API for interacting with block headers
class BlockApi(AbstractAsyncApi):
    # This method will be implemented to fetch the block header for a given block number
    @AbstractAsyncApi.endpoint_jsonrpc
    async def get_block_header(self, *, block_num: int) -> BlockHeaderResponse: ...


# As the final step you need to create a new class that will contain all your custom APIs.
class NewApiCall:
    def __init__(self):
        self.block_api = BlockApi


async def main():
    chain = create_hive_chain()
    extended = chain.extends(NewApiCall)
    print(await extended.api.block_api.get_block_header(block_num=123))


asyncio.run(main())

import { createHiveChain } from '@hiveio/wax';

const chain = await createHiveChain();

interface BlockHeaderRequest {
  blockNum: number;
}

interface BlockHeaderResponse {
  witness: string;
  previous: string;
  timestamp: string;
  extensions: object[];
  transaction_merkle_root: string;
};

// Note: We have to first provide the type of our API with
// proper structure in the generics for IntelliSense
const extended = chain.extendRest<{
  hafahApi: {
    blocks: {
      blockNum: {
        header: {
          params: BlockHeaderRequest;
          result: BlockHeaderResponse;
        }
      }
    }
  }
}>
// Then here we provide the implementation details as
// a function argument for runtime evaluation.
// This helps to deduce template values in the URL
// (provided {} characters) and potentially change HTTP methods
({
  hafahApi: {
    urlPath: 'hafah-api',
    blocks: {
      blockNum: {
        urlPath: '{blockNum}',
        header: {
          method: 'GET'
        }
      }
    }
  }
});

// Call the hafah API using our extended interface
const result = await extended.restApi.hafahApi.blocks.blockNum.header({
  blockNum: 12345678
});

console.info(result);

import asyncio

from beekeepy.handle.remote import AbstractAsyncApi
from wax import create_hive_chain


# Define a new API client that extends AbstractAsyncApi
class ReputationApi(AbstractAsyncApi):
    def base_path(self) -> str:
        return "/reputation-api"

    # Define a REST endpoint for fetching account reputation
    @AbstractAsyncApi.endpoint_rest().get("/accounts/{account-name}/reputation")
    async def get_account_reputations(self, account_name: str) -> int: ...


# Create a class that contains all custom APIs
class NewApiCall:
    def __init__(self):
        # Add ReputationApi as part of the extended chain interface
        self.reputation_api = ReputationApi


# Example: Extending the chain interface with a custom REST API.
async def main():
    chain = create_hive_chain()
    # Extend the chain with the custom API
    extended = chain.extend_rest(NewApiCall)

    # Call the custom API endpoint through the extended interface
    print(f"Output: {await extended.api.reputation_api.get_account_reputations('gtg')}")


asyncio.run(main())

import JsonRPC from "@hiveio/wax-api-jsonrpc";

const extendedChain = chain.extend(JsonRPC);
// You can now call extendedChain.api[apiType][apiMethod](dataToSend)

import HAfAH from "@hiveio/wax-api-hafah";

const extendedChain = chain.extendRest(HAfAH);
// You can now call extendedChain.restApi...<methodNames>()

import asyncio

from wax import create_hive_chain
from reputation_api.reputation_api_client import ReputationApi


# Class containing additional APIs
class ExtendedApi:
    def __init__(self):
        # Extend the chain interface with the predefined ReputationApi
        self.reputation_api = ReputationApi


async def main():
    chain = create_hive_chain()
    # Create an extended chain with the new API
    extended_chain = chain.extends(new_api=ExtendedApi)

    # Calling methods from ReputationApi through the extended interface
    print(f"Reputation: {await extended_chain.api.reputation_api.accounts_reputation('gtg')}")
    print(f"Version: {await extended_chain.api.reputation_api.version()}")
    print(f"Last synced block: {await extended_chain.api.reputation_api.last_synced_block()}")


asyncio.run(main())