> ## Documentation Index > Fetch the complete documentation index at: https://docs.near.org/llms.txt > Use this file to discover all available pages before exploring further. # Basic Anatomy > Learn the basic anatomy of all smart contracts. export const File = ({children}) => { return children; }; export const Block = ({children}) => { return children; }; export const ExplainCode = ({children, languages}) => { const langList = typeof languages === 'string' ? languages.split(',') : languages || []; const [language, setLanguage] = useState(langList[0]); const [activeBlock, setActiveBlock] = useState(0); const [code, setCode] = useState(null); const blockRefs = useRef({}); const codeContainerRef = useRef(null); const ratioMap = useRef({}); const lang2label = { rust: '🦀 Rust', js: '🌐 JS', ts: '🌐 TS', python: '🐍 Python', go: '🐹 Go' }; const typeAccentClass = { state: 'border-l-4 border-emerald-500', warning: 'border-l-4 border-amber-500', note: 'border-l-4 border-amber-500' }; const accentBorder = t => typeAccentClass[t] || 'border-l-4 border-indigo-500'; function toRaw(ref) { const fullUrl = ref.slice(ref.indexOf('https')); const [url] = fullUrl.split('#'); const [org, repo, , branch, ...pathSeg] = new URL(url).pathname.split('/').slice(1); return `https://raw.githubusercontent.com/${org}/${repo}/${branch}/${pathSeg.join('/')}`; } async function fetchRaw(url, fromLine, toLine) { let res; if (typeof window !== 'undefined') { const validUntil = localStorage.getItem(`${url}-until`); if (validUntil && Number(validUntil) > Date.now()) { res = localStorage.getItem(url); } } if (!res) { try { res = await (await fetch(url)).text(); if (typeof window !== 'undefined') { localStorage.setItem(url, res); localStorage.setItem(`${url}-until`, String(Date.now() + 60000)); } } catch { return 'Error fetching code, please try reloading'; } } let lines = res.split('\n'); const from = fromLine ? Number(fromLine) - 1 : 0; const to = toLine ? Number(toLine) : lines.length; lines = lines.slice(from, to); const indent = lines.reduce((prev, line) => { if (!line.length) return prev; const m = line.match(/^\s+/); return m ? Math.min(prev, m[0].length) : 0; }, Infinity); return lines.map(l => l.slice(indent === Infinity ? 0 : indent)).join('\n'); } function parseHighlights(str) { const set = new Set(); if (!str) return set; String(str).split(',').forEach(part => { const [a, b] = part.trim().split('-'); if (b) { for (let i = Number(a); i <= Number(b); i++) set.add(i); } else if (a) set.add(Number(a)); }); return set; } const childArray = Array.isArray(children) ? children.flat(Infinity) : children ? [children] : []; const blocks = []; const files = []; for (const child of childArray) { if (!child || typeof child !== 'object' || !child.props) continue; if (child.props.highlights !== undefined) { let hl = {}; try { hl = JSON.parse(child.props.highlights); } catch {} if ((language in hl)) { blocks.push({ text: child.props.children, highlight: hl[language], fname: child.props.fname, type: child.props.type }); } } else if (child.props.language === language) { files.push({ ...child.props }); } } const activeFname = blocks[activeBlock]?.fname || files[0]?.fname; const fileKey = `${activeFname}-${language}`; const currentFile = files.find(f => f.fname === activeFname) || files[0]; useEffect(() => { setActiveBlock(0); setCode(null); ratioMap.current = {}; }, [language]); useEffect(() => { const observedEls = Object.entries(blockRefs.current).filter(([, el]) => el); const observer = new IntersectionObserver(entries => { entries.forEach(entry => { const idx = Number(entry.target.dataset.blockIdx); ratioMap.current[idx] = entry.intersectionRatio; }); let bestIdx = -1; let bestRatio = 0; Object.entries(ratioMap.current).forEach(([idx, ratio]) => { if (ratio > bestRatio) { bestRatio = ratio; bestIdx = Number(idx); } }); if (bestIdx !== -1) { setActiveBlock(bestIdx); } else { const zoneTop = window.innerHeight * 0.2; const allAboveZone = Object.entries(blockRefs.current).filter(([, el]) => el).every(([, el]) => el.getBoundingClientRect().bottom < zoneTop); if (allAboveZone) setActiveBlock(-1); } }, { threshold: [0, 0.1, 0.25, 0.5, 0.75, 1], rootMargin: '-20% 0px -50% 0px' }); observedEls.forEach(([idx, el]) => { el.dataset.blockIdx = idx; observer.observe(el); }); return () => observer.disconnect(); }, [blocks.length]); useEffect(() => { const container = codeContainerRef.current; if (!container) return; const firstHL = container.querySelector('[data-first-hl]'); if (!firstHL) return; const targetScrollTop = container.scrollTop + firstHL.getBoundingClientRect().top - container.getBoundingClientRect().top - container.clientHeight / 2 + firstHL.offsetHeight / 2; container.scrollTo({ top: Math.max(0, targetScrollTop), behavior: 'smooth' }); }, [activeBlock]); useEffect(() => { if (!currentFile?.url) return; setCode(null); const rawUrl = toRaw(currentFile.url); fetchRaw(rawUrl, currentFile.start, currentFile.end).then(setCode); }, [fileKey]); const startLine = currentFile?.start ? Number(currentFile.start) : 1; const highlighted = parseHighlights(blocks[activeBlock]?.highlight); const firstHlLine = highlighted.size > 0 ? Math.min(...highlighted) : -1; return
{}
{langList.map(lang => )}
{}
{}
{blocks.map((block, i) =>
{ blockRefs.current[i] = el; }} onClick={() => !block.type && setActiveBlock(i)} className={['px-5 py-4 rounded-md transition-all duration-200', block.type ? `cursor-default ${accentBorder(block.type)} opacity-75` : activeBlock === i ? `cursor-pointer ${accentBorder(block.type)} shadow-sm` : `cursor-pointer ${accentBorder(block.type)} opacity-60 hover:opacity-90`].join(' ')} style={{ backgroundColor: block.type ? 'var(--explain-card-bg)' : activeBlock === i ? 'var(--explain-card-active-bg)' : 'var(--explain-card-bg)', border: !block.type && activeBlock === i ? '1px solid var(--explain-card-border)' : '1px solid transparent' }}> {block.text}
)}
{} {currentFile &&
{}
{currentFile.fname}
View on GitHub
{}
{code === null ?
Loading...
: {code.split('\n').map((line, i) => { const lineNum = startLine + i; const isHL = highlighted.has(i + 1); return ; })}
{lineNum} {line || ' '}
}
}
; }; Let's illustrate the basic anatomy of a simple "Hello World" contract. The code on this page comes from our [Hello NEAR repository](https://github.com/near-examples/hello-near-examples) on GitHub. ### Importing the SDK All contracts will import the **NEAR SDK**, enabling them to [access the execution environment](./environment), [call other contracts](./crosscontract), [transfer tokens](./actions), and much more. You can also use third-party libraries, though some might not work due to the limitations of the contract runtime. ### Contract's Main Structure The contract is described through a structure: * The attributes define which data the contract stores * The functions define its public (and private) interface ### Comment Directives Unlike languages with built-in decorators, the Near Go SDK uses **Comment Directives** to control how your code is compiled into a smart contract. The `near-go` CLI scans your comments for `@contract:` tags — such as `@contract:state`, `@contract:init`, `@contract:view`, `@contract:mutating`, `@contract:payable`, and `@contract:promise_callback` — and generates the contract bindings automatically. **Note:** Methods exported to WASM are automatically converted to `snake_case` (e.g., `SetGreeting` becomes `set_greeting`). ### Contract Class Decorator Note that the contract's class is decorated with `@NearBindgen`. This decorator tells the SDK which class defines the contract, so it knows: 1. What to fetch from storage when the contract is loaded 2. What to store when the contract is done executing 3. The methods that are exposed to the outside world 4. If the contract needs to be initialized (we will cover this later) **Note:** Only one class can be decorated with the `@NearBindgen` decorator ### Python Class Structure In Python, we use a class to define our contract. Unlike JavaScript or Rust, there isn't a specific decorator for the class itself. Instead, each method that should be exposed to the blockchain is decorated with the appropriate decorator (`@view`, `@call`, or `@init`). The contract's state is managed through instance variables and can be persisted using the Storage API or collections. ### Contract Struct Macro Note that the contract's struct definition and the implementation are decorated with macros The `#[near(contract_state)]` macro tells the SDK that this structure defines the contract's state, so it knows: 1. What to fetch from storage when the contract is loaded 2. What to store when the contract is done executing The `#[near]` macro tells the SDK which functions are exposed to the outside world. **Note:** Only one struct can be decorated with the `#[near(contract_state)]` macro. When `near` is built for the wasm32 target, it generates the external NEAR contract bindings. To achieve this it is actually generating another function with the signature `pub extern "C" fn function_name()` that first deserializes the contract struct from NEAR storage and then calls the `contract.function_name(parameter1, parameter2, ...)`. If you have annotated your function with any attribute-like macros, these are then executed *twice*. Specifically if the attribute like macro makes any modification to the function signature, or inserts any code that depends on the contract struct (in the form of `&self`, `&mut self`, or `self`) this will fail in the second invocation, because the externally exposed function does not have any concept of this struct. It is possible to detect this by checking which build target you are building for and limit the execution of the macro to operate only on the first pass. ### Storage (State) We call the data stored in the contract [the contract's state](./storage). In our Hello World example, the contract stores a single string (`greeting`), and the state starts initialized with the default value `"Hello"`. **Note:** We will cover more about the contract's state in the [state section](./storage). Javascript contracts need to further include a `schema` object that defines the contract's state and its types. This object is used by the SDK to correctly serialize and deserialize the contract's state. ### Method Decorators In Python, contract methods are decorated with `@view`, `@call`, or `@init` to define how they can be accessed. These decorators handle input parsing and serializing return values automatically. ### Read Only Functions Contract's functions can be read-only, meaning they don't modify the state. Calling them is free for everyone, and does not require to have a NEAR account. **Note:** We will cover more about function types in the [functions section](./functions). ### State Mutating Functions Functions that modify the state or call other contracts are considered state mutating functions. It is necessary to have a NEAR account to call them, as they require a transaction to be sent to the network. **Note:** We will cover more about function types in the [functions section](./functions).