API Reference

curl -X POST https://api.hostcoin.fun \
  -H "Content-Type: application/json" \
  -d '{
    "action":         "deploy",
    "tx_signature":   "HOSTCOIN_DEVNET_TEST",
    "token_name":     "Host Coin",
    "ticker":         "HOST",
    "wallet_address": "11111111111111111111111111111112",
    "twitter_link":   "https://x.com/hostcoin_app",
    "tg_link":        "https://t.me/hostcoinfun",
    "theme":          "cosmic"
  }'

# Response: { "url": "https://hostcoin.fun/host-coin-test", "slug": "host-coin-test" }

import requests

API = 'https://api.hostcoin.fun'
# tx_signature must be a confirmed on-chain SOL transfer to treasury

res = requests.post(API, json={
    'action':           'deploy',
    'token_name':       'Moon Shot',
    'ticker':           'MOON',
    'wallet_address':   'YOUR_WALLET_ADDRESS',
    'tx_signature':     'CONFIRMED_TX_SIG',   # 0.005 SOL to treasury
    'contract_address': '',                    # blank → Stealth Launch
    'twitter_link':     'https://x.com/moonshot',
    'tg_link':          'https://t.me/moonshot',
})

data = res.json()
print(data['url'])   # https://hostcoin.fun/moon-a3f9c1
print(data['slug'])  # moon-a3f9c1

import time, base64, requests
from solders.keypair import Keypair

keypair = Keypair.from_base58_string('YOUR_PRIVATE_KEY')
slug    = 'moon-a3f9c1'
new_ca  = 'MoonMintAddressBase58...'

ts      = int(time.time() * 1000)
msg     = f'Authorize Hostcoin: update_mint for {slug} to {new_ca} at {ts}'.encode()
sig_b64 = base64.b64encode(bytes(keypair.sign_message(msg))).decode()

res = requests.post('https://api.hostcoin.fun', json={
    'action':         'update_mint',
    'slug':           slug,
    'new_ca':         new_ca,
    'wallet_address': str(keypair.pubkey()),
    'signature':      sig_b64,
    'timestamp':      ts,
})
print(res.json())  # {'success': True}

import time, base64, requests
from solders.keypair import Keypair

keypair = Keypair.from_base58_string('YOUR_PRIVATE_KEY')
ts      = int(time.time() * 1000)
msg     = f'Authorize Hostcoin: list_sites at {ts}'.encode()
sig_b64 = base64.b64encode(bytes(keypair.sign_message(msg))).decode()

res = requests.post('https://api.hostcoin.fun', json={
    'action':     'list_sites',
    'public_key': str(keypair.pubkey()),
    'signature':  sig_b64,
    'timestamp':  ts,
})
for site in res.json()['sites']:
    print(site['slug'], '→', site['url'])

# pip install solders
import time, base64
from solders.keypair import Keypair

keypair = Keypair.from_base58_string("YOUR_PRIVATE_KEY")
slug    = "moon-a3f9c1"

# delete_site — timestamp must be within ±60s
ts      = int(time.time() * 1000)
message = f"Authorize Hostcoin: delete_site for {slug} at {ts}".encode()
sig_b64 = base64.b64encode(bytes(keypair.sign_message(message))).decode()

# Pass sig_b64 and ts in the delete_site request body.

# pip install requests solders solana-py
import hashlib, requests
from solders.keypair        import Keypair
from solders.pubkey         import Pubkey
from solders.instruction    import Instruction, AccountMeta
from solders.system_program import transfer, TransferParams
from solders.message        import MessageV0
from solders.transaction    import VersionedTransaction
from solana.rpc.api         import Client as SolanaClient
from solana.rpc.types       import TxOpts

HOSTCOIN_API    = 'https://api.hostcoin.fun'
PUMPPORTAL_API  = 'https://pumpportal.fun/api'
RPC             = 'https://api.mainnet-beta.solana.com'
TREASURY        = Pubkey.from_string('AUEuoaUejiZAzXBByJP6JqnAixaJUmtiuBDJwdpj8BfR')
MEMO_PROGRAM    = Pubkey.from_string('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr')
PRICE_LAMPORTS  = 5_000_000   # 0.005 SOL

keypair     = Keypair.from_base58_string('YOUR_PRIVATE_KEY')
wallet      = str(keypair.pubkey())
TICKER      = 'MOON'
TOKEN_NAME  = 'Moon Shot'
DESCRIPTION = 'The next moonshot on Solana.'
TWITTER     = 'https://x.com/moonshot'
TG          = 'https://t.me/moonshot'
LOGO_URL    = 'https://your-cdn.com/logo.png'
THEME       = 'cosmic'
IMAGE_PATH  = 'logo.png'


def compute_payload_hash(token_name, description='', logo_url='', twitter_link='', tg_link='', theme=''):
    """Must match server-side hash — same field order and separator."""
    parts = [token_name or '', (description or '').strip(),
             (logo_url or '').strip(), twitter_link or '', tg_link or '', theme or '']
    return hashlib.sha256('|'.join(parts).encode()).hexdigest()[:16]


# ── 1. Generate fresh mint keypair — CA is known before minting ──
mint_keypair = Keypair()
mint_addr    = str(mint_keypair.pubkey())


# ── 2. Pay Hostcoin (0.005 SOL) and deploy site ──
conn         = SolanaClient(RPC)
payload_hash = compute_payload_hash(TOKEN_NAME, DESCRIPTION, LOGO_URL, TWITTER, TG, THEME)
memo_text    = f'Hostcoin Deploy: {TICKER.upper()}:{payload_hash}'

bh          = conn.get_latest_blockhash().value.blockhash
transfer_ix = transfer(TransferParams(from_pubkey=keypair.pubkey(), to_pubkey=TREASURY, lamports=PRICE_LAMPORTS))
memo_ix     = Instruction(
    program_id=MEMO_PROGRAM,
    accounts=[AccountMeta(pubkey=keypair.pubkey(), is_signer=True, is_writable=False)],
    data=memo_text.encode('utf-8'),
)
msg        = MessageV0.try_compile(keypair.pubkey(), [transfer_ix, memo_ix], [], bh)
pay_tx     = VersionedTransaction(msg, [keypair])
pay_result = conn.send_raw_transaction(bytes(pay_tx), opts=TxOpts(preflight_commitment='confirmed'))
conn.confirm_transaction(pay_result.value, commitment='confirmed')

r = requests.post(HOSTCOIN_API, json={
    'action':           'deploy',
    'tx_signature':     str(pay_result.value),
    'token_name':       TOKEN_NAME,
    'ticker':           TICKER,
    'wallet_address':   wallet,
    'contract_address': mint_addr,   # CA known upfront — no update_mint needed
    'description':      DESCRIPTION,
    'twitter_link':     TWITTER,
    'tg_link':          TG,
    'logo_url':         LOGO_URL,
    'theme':            THEME,
}, timeout=30)
r.raise_for_status()
site_url = r.json()['url']   # https://hostcoin.fun/moon-a3f9c1
slug     = r.json()['slug']
print(f'Site live: {site_url}')


# ── 3. Upload token metadata to Pump.fun IPFS ──
# site_url is now known — embed it as the token website
with open(IMAGE_PATH, 'rb') as img:
    ipfs = requests.post('https://pump.fun/api/ipfs', files={
        'file':        ('logo.png', img, 'image/png'),
        'name':        (None, TOKEN_NAME),
        'symbol':      (None, TICKER),
        'description': (None, DESCRIPTION),
        'twitter':     (None, TWITTER),
        'telegram':    (None, TG),
        'website':     (None, site_url),  # your new Hostcoin site
        'showName':    (None, 'true'),
    })
ipfs.raise_for_status()
metadata_uri = ipfs.json()['metadataUri']


# ── 4. Create token on Pump.fun via PumpPortal ──
create = requests.post(f'{PUMPPORTAL_API}/trade-local', json={
    'publicKey':        wallet,
    'action':           'create',
    'tokenMetadata':    {'name': TOKEN_NAME, 'symbol': TICKER, 'uri': metadata_uri},
    'mint':             mint_addr,
    'denominatedInSol': 'true',
    'amount':           0.1,     # initial dev buy in SOL
    'slippage':         10,
    'priorityFee':      0.0005,
    'pool':             'pump',
}, timeout=30)
create.raise_for_status()

tx     = VersionedTransaction.from_bytes(create.content)
signed = VersionedTransaction(tx.message, [keypair, mint_keypair])
send_r = conn.send_raw_transaction(bytes(signed))
conn.confirm_transaction(send_r.value, commitment='confirmed')

print(f'\n  Site:        {site_url}')
print(f'  DexScreener: https://dexscreener.com/solana/{mint_addr}')