> ## 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. # SDK Types > Learn everything the SDK has to offer to efficiently store data. 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 || ' '}
}
}
; }; Lets discuss which types smart contracts use to input and output data, as well as how such data is stored and handled in the contract's code. ### Native Types Smart contracts can receive, store and return data using JS native types: * `string` * `number` * `boolean` * `Array` * `Map` * `Object` * `BigInt` ### Native Types Smart contracts can receive, store and return data using the following Rust types: * `string` * `i8-i32/u8-u32` * **`u64/128`**: It is preferable to use SDK types `U64` and `U128` * `bool` * `HashMap` * `Vector` ### Native Types Smart contracts can receive, store and return data using the following Python types: * `str` * `int` * `float` * `bool` * `list` * `dict` * `set` * `bytes` * `None` ### Native Types Smart contracts can receive, store and return data using the following Go types: * `string` * `uint64`, `int64`, `float64` * `bool` * Custom structs (with `json:"..."` tags for serialization) **Note:** Go does not have a native 128-bit integer type. Use `types.Uint128` from the SDK to handle large token amounts. **`U64/U128`** Smart contracts can store `u64` and `u128`, but these types need to be converted to `string` for input/output, since JSON cannot serialize values with more than 52 bits To simplify development, the SDK provides the `U64` and `U128` types which are automatically casted to `u64/u128` when stored, and to `string` when used as input/output **Python Large Numbers** Python's `int` type has unlimited precision, so it can handle large integers (like yoctoNEAR values) without any special handling. All values are automatically serialized and deserialized correctly. **`types.Uint128`** Go does not have a native 128-bit integer type. The SDK provides `types.Uint128` to handle large token amounts (e.g. yoctoNEAR values). Use `types.U128FromString(str)` to parse from a string, and `.String()` to convert back for output. Use `types.U64ToUint128(n)` for small constants. ### Complex Objects Smart contracts can store and return complex objects **Note:** Objects will always be received and returned as JSON #### Serializers Objects that will be used as input or output need to be serializable to JSON, add the `#[near(serializer=json)]` macro Objects that will be stored in the contract's state need to be serializable to Borsh, add the `#[near(serializer=borsh)]` macro #### JSON Tags In Go, struct fields used as input, output, or contract state must have `json:"field_name"` tags. The SDK uses these tags to serialize and deserialize data automatically. #### Serialization Python objects are automatically serialized and deserialized using JSON for input/output and Pickle for internal storage. Complex nested objects like lists and dictionaries can be used directly without additional configuration. ### Handling Tokens `$NEAR` tokens are typed as `BigInt` in JS, and their values represented in `yoctonear` **Note:** 1 NEAR = 10^24 yoctoNEAR ### Handling Tokens `$NEAR` tokens are handled through the `NearToken` struct, which exposes methods to represent the value in `yoctonear`, `milinear` and `near` **Note:** 1 NEAR = 10^24 yoctonear ### Handling Tokens `$NEAR` tokens are represented as integers in Python, with values in `yoctoNEAR`. The `near_sdk_py.constants` module provides `ONE_NEAR` and `ONE_TGAS` constants. **Note:** 1 NEAR = 10^24 yoctoNEAR ### Handling Tokens `$NEAR` tokens are represented as `types.Uint128` in Go, with values in `yoctoNEAR`. * `env.GetAttachedDeposit()` returns the attached deposit as `types.Uint128` * `types.U128FromString(str)` parses a token amount from string * `types.U64ToUint128(n)` converts a small constant to `Uint128` * `.String()` converts back to string for storage or output **Note:** 1 NEAR = 10^24 yoctoNEAR ### Account The SDK exposes a special type to handle NEAR Accounts, which automatically checks if the account address is valid ### Account IDs In Python, NEAR account IDs are represented as `str` types. The SDK performs validation when account IDs are used in contract calls or cross-contract interactions. ### Account IDs In Go, NEAR account IDs are represented as `string`. Functions like `env.GetPredecessorAccountID()` and `env.GetCurrentAccountId()` return account IDs as plain strings.