Goliath Slingshot

Official Decentralized Exchange

Goliath Slingshot is the official constant product-based Automated Market Maker (AMM) decentralized exchange (DEX) for the Goliath Network.

Access Slingshot: https://slingshot.goliath.net/

Overview

Slingshot is a Uniswap V2-like constant product DEX implementing the formula (x * y = k), enabling trustless token swaps directly on the Goliath blockchain. Users can:

• Swap tokens instantly without order books or counterparties

• Provide liquidity to earn trading fees from swap transactions

• Create trading pairs for new tokens in the ecosystem

Supported Tokens

Slingshot supports the following official ERC20 tokens on Goliath Testnet:

Token	Contract Address	Decimals	Status
WXCN (Wrapped XCN)	0xec6Cd1441201e36F7289f0B2729a97d091AcB5b7	8	Verified
ETH	0x9d318b851a6AF920D467bC5dC9882b5DFD36D65e	18	Submitted
BTC	0xF568bE1D688353d2813810aA6DaF1cB1dCe38D7E	8	Verified
USDC	0xEf2B9f754405f52c80B5A67656f14672a00d23b4	6	Submitted
XAUX (Onyx Gold)	0xEC3507BAF55C241e44036a94Cb9c02b15A78E863	18	Submitted
XAGX (Onyx Silver)	0x820037622659fF123a01bB94A720854C8A7609C0	18	Submitted

WXCN (Wrapped XCN) is the ERC20-wrapped version of the native XCN token, enabling it to be traded on AMM protocols like Slingshot.

Get Test Tokens: ETH and USDC test tokens can be obtained from the Goliath Faucet Bot on Telegram.

How It Works

Constant Product Formula

Slingshot uses the constant product market maker model:

x * y = k

Where:

• x = reserve of token A

• y = reserve of token B

• k = constant product (invariant)

This formula ensures that the product of reserves remains constant after every trade, automatically determining prices based on supply and demand.

Trading Fees

A 0.3% fee is charged on all swaps:

• 0.25% goes to liquidity providers

• 0.05% reserved for protocol development

Liquidity Provision

Liquidity providers (LPs) deposit equal values of two tokens into a pool and receive LP tokens representing their share. LPs earn proportional trading fees from all swaps in their pool.

Getting Started

1. Connect Your Wallet

Visit slingshot.goliath.net and connect a Web3 wallet (MetaMask recommended) configured for Goliath Testnet.

2. Get Test Tokens

Obtain testnet XCN from the Goliath Faucet Bot to pay for gas fees.

3. Swap Tokens

Select the tokens you want to swap, enter the amount, and confirm the transaction in your wallet.

4. Add Liquidity

Navigate to the Pool section, select a token pair, and deposit equal values of both tokens to start earning fees.

---

Cross-Chain Bridge

Slingshot includes a built-in bridge for transferring assets between Ethereum Sepolia testnet and Goliath Testnet.

Access the Bridge: https://slingshot.goliath.net/#/bridge

Supported Bridge Assets

Asset	Sepolia → Goliath	Goliath → Sepolia	Status
ETH	✅	✅	Live
USDC	🔜	🔜	Coming Soon
BTC	🔜	🔜	Coming Soon

Currently Supported: Only ETH bridging is available at this time. More assets will be added in future updates.

---

User Guide: How to Bridge

Prerequisites

Before using the bridge, ensure you have:

1. MetaMask or another Web3 wallet installed

2. Sepolia ETH for bridging (get from Sepolia Faucet)

3. XCN tokens on Goliath for gas fees (get from Goliath Faucet Bot)

4. Both networks configured in your wallet

Network Configuration

Add these networks to your wallet:

Network	Chain ID	RPC URL	Currency
Goliath Testnet	8901	https://rpc.testnet.goliath.net	XCN
Sepolia	11155111	https://ethereum-sepolia-rpc.publicnode.com	ETH

Bridging from Sepolia to Goliath (Deposit)

This transfers native ETH from Sepolia and mints wrapped ETH (ERC-20) on Goliath.

Step-by-Step:

1. Visit the Bridge

   • Go to slingshot.goliath.net/#/bridge

2. Connect Your Wallet

   • Click "Connect Wallet"

   • Select MetaMask (or your preferred wallet)

   • Ensure you're connected to Sepolia network

3. Configure the Transfer

   • Source: Sepolia (should auto-detect)

   • Destination: Goliath Testnet

   • Token: ETH

   • Enter the amount you want to bridge

4. Initiate the Bridge

   • Click "Bridge"

   • Review the transaction details in the confirmation modal

   • Confirm the transaction in your wallet

5. Wait for Confirmation

   • The bridge requires 10 block confirmations on Sepolia (~2 minutes)

   • A status modal will show your transaction progress

   • Once confirmed, the relayer will mint ETH on Goliath

6. Receive Your Tokens

   • Switch your wallet to Goliath Testnet

   • Add the ETH token to MetaMask: 0x9d318b851a6AF920D467bC5dC9882b5DFD36D65e

   • Your bridged ETH will appear in your balance

Bridging from Goliath to Sepolia (Withdraw)

This burns wrapped ETH on Goliath and releases native ETH on Sepolia.

Step-by-Step:

1. Connect to Goliath Testnet

   • Ensure your wallet is connected to Goliath Testnet (Chain ID: 8901)

2. Approve Token Spending (first time only)

   • If this is your first bridge from Goliath, you'll need to approve the bridge contract

   • Click "Approve" and confirm the transaction

   • Wait for the approval transaction to complete

3. Configure the Transfer

   • Source: Goliath Testnet

   • Destination: Sepolia

   • Token: ETH

   • Enter the amount to bridge

4. Burn and Bridge

   • Click "Bridge"

   • The bridge contract will burn your ETH tokens on Goliath

   • Confirm the transaction in your wallet

5. Wait for Confirmation

   • The bridge requires 6 block confirmations on Goliath (~12 seconds)

   • The relayer will then release ETH on Sepolia

6. Receive Native ETH

   • Switch to Sepolia network

   • Your native ETH will be available in your wallet

Transaction Status

Track your bridge transactions in real-time:

Status	Description
Pending	Transaction submitted, waiting for inclusion
Confirming	Transaction included, waiting for confirmations
Processing	Relayer processing the cross-chain transfer
Completed	Transfer successful on destination chain
Failed	Transaction failed (funds are safe)

Processing Time: Typical bridge transfers complete in 2-5 minutes. Network congestion may cause delays.

---

Developer Guide: Bridge Integration

Bridge Architecture

The Goliath Bridge uses a lock-and-mint / burn-and-release mechanism:

Sepolia → Goliath (Deposit):
┌─────────────┐    ┌──────────────┐    ┌─────────────────┐
│ User sends  │ → │ ETH locked   │ → │ ETH minted on   │
│ native ETH  │    │ on Sepolia   │    │ Goliath (ERC20) │
└─────────────┘    └──────────────┘    └─────────────────┘

Goliath → Sepolia (Withdraw):
┌─────────────┐    ┌──────────────┐    ┌─────────────────┐
│ User burns  │ → │ ETH burned   │ → │ Native ETH      │
│ ETH (ERC20) │    │ on Goliath   │    │ released        │
└─────────────┘    └──────────────┘    └─────────────────┘

Contract Addresses

Contract	Network	Address	Verified
Bridge (Sepolia)	Sepolia	0xA9FD64B5095d626F5A3A67e6DB7FB766345F8092	Yes
Bridge (Goliath)	Goliath	0xB4139A33Ae5DfaB4fE0339b20C254b00179a951d	Yes
Bridged ETH	Goliath	0x9d318b851a6AF920D467bC5dC9882b5DFD36D65e	Yes

Bridge Contract ABIs

Sepolia Bridge (Deposit)

const BRIDGE_SEPOLIA_ABI = [
  // Deposit native ETH (payable)
  {
    name: 'depositNative',
    type: 'function',
    stateMutability: 'payable',
    inputs: [
      { name: 'destinationAddress', type: 'address' }
    ],
    outputs: [
      { name: 'depositId', type: 'bytes32' }
    ]
  },
  // Deposit ERC-20 tokens
  {
    name: 'deposit',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'token', type: 'address' },
      { name: 'amount', type: 'uint256' },
      { name: 'destinationAddress', type: 'address' }
    ],
    outputs: [
      { name: 'depositId', type: 'bytes32' }
    ]
  },
  // Deposit event
  {
    name: 'Deposit',
    type: 'event',
    inputs: [
      { indexed: true, name: 'depositId', type: 'bytes32' },
      { indexed: true, name: 'token', type: 'address' },
      { indexed: true, name: 'sender', type: 'address' },
      { indexed: false, name: 'destinationAddress', type: 'address' },
      { indexed: false, name: 'amount', type: 'uint256' },
      { indexed: false, name: 'timestamp', type: 'uint64' },
      { indexed: false, name: 'sourceChainId', type: 'uint64' }
    ]
  }
];

Goliath Bridge (Withdraw)

const BRIDGE_GOLIATH_ABI = [
  // Burn tokens to withdraw
  {
    name: 'burn',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'token', type: 'address' },
      { name: 'amount', type: 'uint256' },
      { name: 'destinationAddress', type: 'address' }
    ],
    outputs: [
      { name: 'withdrawId', type: 'bytes32' }
    ]
  },
  // Withdraw event
  {
    name: 'Withdraw',
    type: 'event',
    inputs: [
      { indexed: true, name: 'withdrawId', type: 'bytes32' },
      { indexed: true, name: 'token', type: 'address' },
      { indexed: true, name: 'sender', type: 'address' },
      { indexed: false, name: 'destinationAddress', type: 'address' },
      { indexed: false, name: 'amount', type: 'uint256' },
      { indexed: false, name: 'timestamp', type: 'uint64' },
      { indexed: false, name: 'sourceChainId', type: 'uint64' }
    ]
  }
];

Integration Examples

Example 1: Bridge ETH from Sepolia to Goliath

const { ethers } = require('ethers');

// Connect to Sepolia
const provider = new ethers.JsonRpcProvider('https://ethereum-sepolia-rpc.publicnode.com');
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

// Bridge contract on Sepolia
const BRIDGE_ADDRESS = '0xA9FD64B5095d626F5A3A67e6DB7FB766345F8092';
const bridge = new ethers.Contract(BRIDGE_ADDRESS, BRIDGE_SEPOLIA_ABI, wallet);

async function bridgeEthToGoliath(amountEth, destinationAddress) {
  const amountWei = ethers.parseEther(amountEth);

  console.log(`Bridging ${amountEth} ETH to ${destinationAddress} on Goliath...`);

  // Call depositNative with ETH value
  const tx = await bridge.depositNative(destinationAddress, {
    value: amountWei
  });

  console.log('Transaction submitted:', tx.hash);

  // Wait for confirmation
  const receipt = await tx.wait();
  console.log('Deposit confirmed in block:', receipt.blockNumber);

  // Parse deposit event to get depositId
  const depositEvent = receipt.logs.find(log => {
    try {
      return bridge.interface.parseLog(log)?.name === 'Deposit';
    } catch { return false; }
  });

  if (depositEvent) {
    const parsed = bridge.interface.parseLog(depositEvent);
    console.log('Deposit ID:', parsed.args.depositId);
  }

  return receipt;
}

// Usage
bridgeEthToGoliath('0.1', '0xYourGoliathAddress');

Example 2: Bridge ETH from Goliath to Sepolia

const { ethers } = require('ethers');

// Connect to Goliath Testnet
const provider = new ethers.JsonRpcProvider('https://rpc.testnet.goliath.net');
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);

// Addresses
const BRIDGE_ADDRESS = '0xB4139A33Ae5DfaB4fE0339b20C254b00179a951d';
const ETH_TOKEN = '0x9d318b851a6AF920D467bC5dC9882b5DFD36D65e';

// ERC-20 ABI for approval
const ERC20_ABI = [
  'function approve(address spender, uint256 amount) returns (bool)',
  'function allowance(address owner, address spender) view returns (uint256)'
];

async function bridgeEthToSepolia(amountEth, destinationAddress) {
  const amountWei = ethers.parseEther(amountEth);

  // Check and approve if needed
  const ethToken = new ethers.Contract(ETH_TOKEN, ERC20_ABI, wallet);
  const allowance = await ethToken.allowance(wallet.address, BRIDGE_ADDRESS);

  if (allowance < amountWei) {
    console.log('Approving bridge contract...');
    const approveTx = await ethToken.approve(BRIDGE_ADDRESS, ethers.MaxUint256);
    await approveTx.wait();
    console.log('Approval confirmed');
  }

  // Burn tokens on Goliath bridge
  const bridge = new ethers.Contract(BRIDGE_ADDRESS, BRIDGE_GOLIATH_ABI, wallet);

  console.log(`Burning ${amountEth} ETH to release on Sepolia...`);
  const tx = await bridge.burn(ETH_TOKEN, amountWei, destinationAddress);

  console.log('Transaction submitted:', tx.hash);
  const receipt = await tx.wait();
  console.log('Burn confirmed in block:', receipt.blockNumber);

  return receipt;
}

// Usage
bridgeEthToSepolia('0.05', '0xYourSepoliaAddress');

Example 3: Monitor Bridge Events

const { ethers } = require('ethers');

// Listen for deposits on Sepolia
const sepoliaProvider = new ethers.JsonRpcProvider('https://ethereum-sepolia-rpc.publicnode.com');
const sepoliaBridge = new ethers.Contract(
  '0xA9FD64B5095d626F5A3A67e6DB7FB766345F8092',
  BRIDGE_SEPOLIA_ABI,
  sepoliaProvider
);

sepoliaBridge.on('Deposit', (depositId, token, sender, destination, amount, timestamp, chainId, event) => {
  console.log('New Deposit detected:');
  console.log('  Deposit ID:', depositId);
  console.log('  Sender:', sender);
  console.log('  Destination:', destination);
  console.log('  Amount:', ethers.formatEther(amount), 'ETH');
  console.log('  Tx Hash:', event.log.transactionHash);
});

// Listen for withdrawals on Goliath
const goliathProvider = new ethers.JsonRpcProvider('https://rpc.testnet.goliath.net');
const goliathBridge = new ethers.Contract(
  '0xB4139A33Ae5DfaB4fE0339b20C254b00179a951d',
  BRIDGE_GOLIATH_ABI,
  goliathProvider
);

goliathBridge.on('Withdraw', (withdrawId, token, sender, destination, amount, timestamp, chainId, event) => {
  console.log('New Withdraw detected:');
  console.log('  Withdraw ID:', withdrawId);
  console.log('  Sender:', sender);
  console.log('  Destination:', destination);
  console.log('  Amount:', ethers.formatEther(amount), 'ETH');
  console.log('  Tx Hash:', event.log.transactionHash);
});

Bridge Status API

Monitor bridge operations programmatically using the status API:

Base URL: https://testnet.mirrornode.goliath.net/bridge/api/v1

Endpoint	Method	Description
/status/{depositId}	GET	Get status of a deposit operation
/status/{withdrawId}	GET	Get status of a withdraw operation
/history/{address}	GET	Get bridge history for an address

Confirmation Requirements

Direction	Required Confirmations	Estimated Time
Sepolia → Goliath	10 blocks	~2 minutes
Goliath → Sepolia	6 blocks	~12 seconds

Token Addresses Reference

Token	Sepolia	Goliath
ETH	Native (no address)	0x9d318b851a6AF920D467bC5dC9882b5DFD36D65e
USDC	0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238	0xEf2B9f754405f52c80B5A67656f14672a00d23b4

Security Note: Always verify contract addresses before interacting. Never approve unlimited spending on mainnet deployments.

Testnet Only: This bridge operates between testnets (Sepolia and Goliath Testnet). Assets bridged have no real-world value and are for testing purposes only.

---

Developer Reference

Core Contract Addresses

The following contracts power Goliath Slingshot on Testnet:

Contract	Address	Verified
WXCN	0xec6Cd1441201e36F7289f0B2729a97d091AcB5b7	Yes
SlingshotFactory	0x698Ba06870312aEd129fC2e48dc3d002d981aB8E	Yes
SlingshotRouter	0xC47483b7eE4728c7006001f372bFbd8519210654	Yes
Multicall3	0x9a64319f37A02DbFab53f45fddB13Ea6744Fb8C2	Yes

Integration Example

const { ethers } = require('ethers');

// Connect to Goliath Testnet
const provider = new ethers.JsonRpcProvider('https://rpc.testnet.goliath.net');
const signer = new ethers.Wallet(privateKey, provider);

// Contract addresses
const ROUTER_ADDRESS = '0xC47483b7eE4728c7006001f372bFbd8519210654';
const WXCN_ADDRESS = '0xec6Cd1441201e36F7289f0B2729a97d091AcB5b7';
const USDC_ADDRESS = '0x407A137fcdE44E03142f5EE83c32519A3dc0f54d';

// Router ABI (minimal for swaps)
const ROUTER_ABI = [
  'function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] path, address to, uint deadline) returns (uint[] amounts)',
  'function getAmountsOut(uint amountIn, address[] path) view returns (uint[] amounts)'
];

const router = new ethers.Contract(ROUTER_ADDRESS, ROUTER_ABI, signer);

// Get quote for swapping 100 USDC to WXCN
async function getQuote() {
  const amountIn = ethers.parseUnits('100', 6); // USDC has 6 decimals
  const path = [USDC_ADDRESS, WXCN_ADDRESS];

  const amounts = await router.getAmountsOut(amountIn, path);
  console.log('Expected WXCN output:', ethers.formatUnits(amounts[1], 8));
}

// Execute swap
async function swap() {
  const amountIn = ethers.parseUnits('100', 6);
  const amountOutMin = 0; // Set appropriate slippage in production
  const path = [USDC_ADDRESS, WXCN_ADDRESS];
  const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // 20 minutes

  const tx = await router.swapExactTokensForTokens(
    amountIn,
    amountOutMin,
    path,
    signer.address,
    deadline
  );

  await tx.wait();
  console.log('Swap completed:', tx.hash);
}

Factory Interface

const FACTORY_ABI = [
  'function getPair(address tokenA, address tokenB) view returns (address)',
  'function allPairs(uint) view returns (address)',
  'function allPairsLength() view returns (uint)'
];

const factory = new ethers.Contract(
  '0x698Ba06870312aEd129fC2e48dc3d002d981aB8E',
  FACTORY_ABI,
  provider
);

// Get pair address for WXCN/USDC
const pairAddress = await factory.getPair(WXCN_ADDRESS, USDC_ADDRESS);

Multicall for Batch Queries

Use the Multicall contract to batch multiple read calls into a single RPC request:

const MULTICALL3_ADDRESS = '0x9a64319f37A02DbFab53f45fddB13Ea6744Fb8C2';

Resources

• Slingshot App: https://slingshot.goliath.net/

• Block Explorer: https://testnet.explorer.goliath.net/

• Testnet Faucet: Goliath Faucet Bot